<!-- generated: 2026-05-27 from docs.bytebrew.io + bytebrew.io + listed videos -->
<!--
  For LLMs and agents reading this file:
  - This is the expanded corpus. For a smaller index file with the same link
    structure but lighter per-page descriptions, see:
    https://bytebrew.io/llms.txt  (root, spec-mandated discoverable location)
    https://docs.bytebrew.io/llms.txt  (mirror)
  - Every section below corresponds to a canonical docs page on
    https://docs.bytebrew.io. When this file conflicts with a live docs page,
    the live page wins - it is the source of truth and updated more frequently.
  - The product is structured around three pillars: Analyze, Operate, Grow.
    Marketing pages: https://bytebrew.io/analyze /operate /grow.
  - Code snippets are verbatim from the docs or from ByteBrew video tutorials,
    each tagged with a `// source:` comment for traceability. Preserve casing
    of method names, event names, and parameter keys.
-->

# ByteBrew

> ByteBrew is an all-in-one mobile app and game growth platform organized around three pillars - **Analyze** (real-time engagement, retention, monetization, LTV, funnels, breakdowns, cohorts, mechanics, journeys), **Operate** (Live Ops with Remote Configs, A/B Tests, push notifications, attribution), and **Grow** (ByteBrew Ads cross-promotion powered by the Ctrl AI behavioral targeting engine and the Alt creative-serving engine). Developers integrate a single lightweight SDK to unlock every tool on the dashboard for free, with real-time data streaming, server-side IAP validation, impression-level ad revenue tracking, free attribution measurement across integrated networks, SKAN support, and a 24-month historical query window. Supported platforms: Unity, iOS (Swift), Android, Godot, GameMaker, Flutter, React Native, Unreal, .NET MAUI, Cordova, and JavaScript (Web). All dashboard data operates in UTC.

> **For agents and LLMs:** This is the full expanded corpus. The lighter index is at [bytebrew.io/llms.txt](https://bytebrew.io/llms.txt) (also mirrored at [docs.bytebrew.io/llms.txt](https://docs.bytebrew.io/llms.txt)). The canonical live documentation is at [docs.bytebrew.io](https://docs.bytebrew.io) - fetch the specific page linked under each section below when you need content beyond what's reproduced here.

## Product Overview

ByteBrew's marketing organizes the platform around three product pillars. These are described at the company's main site and inform how the tools relate to each other.

### Analyze (real-time analytics stack)
The Analyze product is a comprehensive analytics stack connected to every part of an app. Capabilities include: identifying how users behave each day they return; mapping user journeys to visualize how players interact with the app; uncovering when and where cohorts of users reach conversion points; drilling into events and parameters for actionable insight; building Funnels to track how users transition through each stage step by step; measuring real lifetime value connected to all revenue sources; securing in-app purchases with real-time server-side purchase validation; and accessing a comprehensive view of monetization performance with Revenue Reports.

### Operate (Live Ops stack)
The Operate product is a Live Ops stack enabling teams to operate at the speed of insight. Capabilities include: shipping live remote updates globally with Remote Configs; distributing custom live updates to user segments with Remote Config Conditions; sending JSON payloads bundled in a single update via the Config JSON Editor; building multi-variant in-app experiments with A/B Tests; analyzing how A/B Test variants impact app metrics and rolling out winning variants; measuring attributed installs from marketing campaigns across connected networks; getting a clear view of acquisition performance metrics; and designing, automating, and delivering cross-platform push notifications globally or to specific user cohorts.

### Grow (ByteBrew Ads / Ctrl)
The Grow product is ByteBrew Ads - an AI-layered cross-promotion network built to scale a portfolio with performance-targeted growth. **Ctrl** is the AI behavioral targeting engine powering ByteBrew Ads, delivering smarter acquisition decisions in real-time to maximize marketing performance. **Alt** is the AI vision engine that dynamically serves creatives in a campaign most likely to drive engagement. Capabilities include: launching campaigns across the globe or within specific regions; ad types tailored to seamlessly fit within existing ad slots; LTV Campaigns powered by Ctrl that target valuable users across a portfolio; Retention Campaigns powered by Ctrl that target retaining players; building an ecosystem by capturing quality users and transitioning them across a portfolio; directly launching, managing, and analyzing live campaigns; measuring campaign performance with built-in platform tools; self-reporting attribution built at its core; and an AI layer embedded across the ad stack to capture high-value users and fill open ad space with engaging creatives.

## Getting Started

### [Developer Hub](https://docs.bytebrew.io/)
Welcome to the ByteBrew Developer Hub. The hub contains comprehensive guides, documentation, and tutorial videos covering the full platform. ByteBrew is described as all-in-one because the single, lightweight SDK is the only SDK required to access every tool on the platform - no additional SDKs are needed for ads, attribution, push, IAP validation, remote configs, or A/B testing. The platform monetizes through ByteBrew Ads and the Ctrl Engine. Over 15,000 developers use ByteBrew.

### [Setup Apps](https://docs.bytebrew.io/startup/home)
Create a ByteBrew account to access the dashboard. To create a new app, hit the green "+ Add New" button and input the required info on the prompt (App title, App name, Bundle Identifier, Genre, App ID, Shared Secret) and click Create. The platform automatically redirects to the app's settings page where the Game ID and SDK Key can be copied. These keys go into the SDK initialization call (or, for Unity, into the ByteBrew settings inspector).

### [Add Apps](https://docs.bytebrew.io/startup/addgames)
The Add Apps flow covers adding a new app to your studio. Required fields include App title, App name, Bundle Identifier, Genre, App ID, and Shared Secret (for iOS purchase validation).

### [App Settings](https://docs.bytebrew.io/dashboard/gamesettings)
The App Settings page is where you input the **Apple App Shared Secret** and the **Google License Key** - these are required for ByteBrew to perform server-side IAP validation against the App Store and Play Store. Without them, purchase tracking still works but server-side validation does not.

## SDK Integration

### Unity SDK (priority)
- [Unity SDK Overview](https://docs.bytebrew.io/sdk/unity): Integrate the ByteBrew SDK for Unity covering analytics, ads, IAP validation, remote configs, and ATT.

**Overview**
ByteBrew supports Android 5.1 and above & iOS version 9.0 and above. ByteBrew SDK is compatible with iOS 14 updates. Place the ByteBrew GameObject on the first scene of the game so session lengths and play times are tracked cleanly. ByteBrew SDK does not support offline event caching.

**Install / Setup**
```csharp
// source: https://docs.bytebrew.io/sdk/unity
// Import ByteBrew Unity SDK to your project. (Android Only) If you don't use Auto-Resolve on your External Dependency Manager, then after importing the SDK, go to Assets, find External Dependency Manager, select Android Resolver, and click Force Resolve.
```

**Unity Settings Inspector**
1. Go to Window -> ByteBrew -> Choose "Create ByteBrew GameObject".
2. Go to Window -> ByteBrew -> Choose "Select ByteBrew settings".
3. Enable which platforms (iOS, Android and Web) you want to track on the Unity ByteBrew settings inspector panel.
4. Input the platform specific Game IDs and SDK Key from your game on the ByteBrew dashboard into the Unity ByteBrew settings inspector panel.
*Note: When updating the ByteBrew SDK, make sure to re-input your Game Keys and SDK Key after updating.*

**Initialize**
```csharp
// source: https://docs.bytebrew.io/sdk/unity
// Initialize ByteBrew and ByteBrew Ads 
ByteBrew.InitializeByteBrew(); 
ByteBrewAds.InitializeAds();
```

**App Tracking Transparency (iOS) - wrap Initialize in the ATT callback**
```csharp
// source: https://docs.bytebrew.io/sdk/unity
// Call ByteBrew ATT Wrapper
ByteBrew.requestForAppTrackingTransparency((status) => 
{
    //case 0: ATTrackingManagerAuthorizationStatusAuthorized
    //case 1: ATTrackingManagerAuthorizationStatusDenied
    //case 2: ATTrackingManagerAuthorizationStatusRestricted
    //case 3: ATTrackingManagerAuthorizationStatusNotDetermined
    Debug.Log("ByteBrew got a status of: " + status);
    ByteBrew.InitializeByteBrew();
});
```

**Track a custom event**
```csharp
// source: https://docs.bytebrew.io/sdk/unity
//Basic Custom Event without any sub-parameters 
ByteBrew.NewCustomEvent("eventName"); 
```

**Track a custom event with parameters using Dictionary**
```csharp
// source: https://docs.bytebrew.io/sdk/unity
//Example Event 
var mapCheckpointParameters = new Dictionary<string, string>() { 
    { "earned", "KARMA" }, 
    { "amount", "500" } 
};
ByteBrew.NewCustomEvent("eventName", mapCheckpointParameters); 
```
*Note: Do not use special characters, such as (1) spaces, (2) periods ".", or (3) colons ":" in your custom events or parameters. As an alternative to spaces, use "_".*

**Set user attribute (Data Attributes)**
```csharp
// source: https://docs.bytebrew.io/sdk/unity
ByteBrew.SetCustomUserDataAttribute("dundees", 3); 
ByteBrew.SetCustomUserDataAttribute("loves_the_office", true);
```
*Note: Data Attributes should not be spammed or used to continuously update a set of values for a single user (e.g. updating multiple times per second).*

**Log ad revenue**
```csharp
// source: https://docs.bytebrew.io/sdk/unity
// Record the Placement Type, Provider of the ad, ad unit name, and revenue of the impression (all revenue must be real dollar/pennies amount and in USD)
ByteBrew.TrackAdEvent(ByteBrewAdTypes.Interstitial, "Google AdMob", "Interstitial_Unit_Name", 0.00074145); 
ByteBrew.TrackAdEvent(ByteBrewAdTypes.Reward, "Unity Ads", "Reward_Unit_Name", 0.005562); 

//Add your ad units placement location in your game to breakdown your impression more. (all revenue must be real dollar/pennies amount and in USD)
ByteBrew.TrackAdEvent(ByteBrewAdTypes.Interstitial, "Google AdMob", "Interstitial_Unit_Name", "Interstitial_EndOfLevel", 0.0024145);
```

**Setup Ads (Listeners and Loading)**
```csharp
// source: https://docs.bytebrew.io/sdk/unity#SetupAds
// Gotcha: Important Do not oversubscribe to unnecessary ad event listeners or subscribe multiple times to the same listeners.

// Init
ByteBrewAds.OnAdsInitSuccess += OnAdsInitSuccess;
ByteBrewAds.OnAdsInitFailure += OnAdsInitFailed;

// Interstitial

// Load
ByteBrewAds.OnInterstitialAdLoaded += OnInterstitialAdLoaded;
ByteBrewAds.OnInterstitialAdLoadError += OnInterstitialAdLoadError;
// Events
ByteBrewAds.OnInterstitialAdStarted += OnInterstitialAdStarted;
ByteBrewAds.OnInterstitialAdClicked += OnInterstitialAdClicked;
ByteBrewAds.OnInterstitialAdCompleted += OnInterstitialAdCompleted;
ByteBrewAds.OnInterstitialAdDismissed += OnInterstitialAdDismissed;
ByteBrewAds.OnInterstitialAdError += OnInterstitialAdError;

// Rewarded

// Load
ByteBrewAds.OnRewardedAdLoaded += OnRewardedAdLoaded;
ByteBrewAds.OnRewardedAdLoadError += OnRewardedAdLoadError;
// Events
ByteBrewAds.OnRewardedAdStarted += OnRewardedAdStarted;
ByteBrewAds.OnRewardedAdClicked += OnRewardedAdClicked;
ByteBrewAds.OnRewardedAdCompleted += OnRewardedAdCompleted;
ByteBrewAds.OnRewardedAdRewarded += OnRewardedAdRewarded;
ByteBrewAds.OnRewardedAdDismissed += OnRewardedAdDismissed;
ByteBrewAds.OnRewardedAdError += OnRewardedAdError;


// Method Signatures
private static void OnAdsInitSuccess() {
    // We can now start loading ads (See next section for more details)
    ByteBrewAds.LoadInterstitialCrossPromoAd(_BBInterstitialAdUnitId, true);
    ByteBrewAds.LoadInterstitialCrossPromoAd(_BBInterstitialAdUnitId);
    ByteBrewAds.LoadRewardedCrossPromoAd(_BBRewardedAdUnitId, true);
    ByteBrewAds.LoadRewardedCrossPromoAd(_BBRewardedAdUnitId);
}

private static void OnAdsInitFailed() {}

// Interstitial
private static void OnInterstitialAdLoaded(ByteBrewAdDataCommon adData) {}
private static void OnInterstitialAdLoadError(string error, ByteBrewAdDataCommon adData) {}
private static void OnInterstitialAdStarted(ByteBrewAdDataCommon adData) {}
private static void OnInterstitialAdClicked(ByteBrewAdDataCommon adData) {}
private static void OnInterstitialAdCompleted(ByteBrewAdDataCommon adData) {}
private static void OnInterstitialAdDismissed(ByteBrewAdDataCommon adData) {}
private static void OnInterstitialAdError(string error, ByteBrewAdDataCommon adData) {}

// Rewarded
private static void OnRewardedAdLoaded(ByteBrewAdDataCommon adData) {}
private static void OnRewardedAdLoadError(string error, ByteBrewAdDataCommon adData) {}
private static void OnRewardedAdStarted(ByteBrewAdDataCommon adData) {}
private static void OnRewardedAdClicked(ByteBrewAdDataCommon adData) {}
private static void OnRewardedAdCompleted(ByteBrewAdDataCommon adData) {}
private static void OnRewardedAdRewarded(ByteBrewAdDataCommon adData) {}
private static void OnRewardedAdDismissed(ByteBrewAdDataCommon adData) {}
private static void OnRewardedAdError(string error, ByteBrewAdDataCommon adData) {}
```

**Setup Ads (Showing Interstitial / Ctrl Engine)**
```csharp
// source: https://docs.bytebrew.io/sdk/unity#SetupAds
// Gotcha: Use ctrlOnly: true to capture high-value targeted users first. 
// Omit ctrlOnly (or set false) as a fallback to fill empty ad space if your primary monetization partner fails to load.

//Call Ctrl targetted ad to capture high-value users
if (ByteBrewAds.IsCrossPromoAdLoaded(_BBInterstitialAdUnitId, ctrlOnly: true))
{
  ByteBrewAds.ShowInterstitialCrossPromoAd(_BBInterstitialAdUnitId, ctrlOnly: true);
}
else if(YOUR_MONETIZATION_PARTNER_STATUS)
{
  //SHOW YOUR MONETIZATION PARTNER
}
else if (ByteBrewAds.IsCrossPromoAdLoaded(_BBInterstitialAdUnitId)) //Check and show an ad
{
  //Call to fill empty ad space
  ByteBrewAds.ShowInterstitialCrossPromoAd(_BBInterstitialAdUnitId);
}
```

**In-App Purchase Tracking with Server-Side Validation**
```csharp
// source: video Server-Side Purchase Validation at 01:00
// Gotcha: Make sure the receipts have correct JSON string formatting. 
// Do not reward users for purchases until the receipt is explicitly validated as true via the callback to prevent fraud.
// Use MiniJson to correctly deserialize the Unity IAP payload inside your ProcessPurchase method.

public PurchaseProcessingResult ProcessPurchase(PurchaseEventArgs e)
{
    // Decode the initial receipt payload
    var dictionary = (Dictionary<string, object>)MiniJson.JsonDecode(e.purchasedProduct.receipt);
    string receiptPayload = (string)dictionary["Payload"];

#if UNITY_ANDROID
    // Android requires parsing the payload again to extract the JSON and signature
    var payloadDict = (Dictionary<string, object>)MiniJson.JsonDecode(receiptPayload);
    string googleReceipt = (string)payloadDict["json"];
    string googleSignature = (string)payloadDict["signature"];

    ByteBrew.ValidateGoogleInAppPurchaseEvent("Google Play Store", e.purchasedProduct.metadata.isoCurrencyCode, (float)e.purchasedProduct.metadata.localizedPrice, e.purchasedProduct.definition.storeSpecificId, e.purchasedProduct.definition.id, googleReceipt, googleSignature, (purchaseResultData) => {
        if (purchaseResultData.purchaseProcessed) {
            if (purchaseResultData.isValid) {
                Debug.Log("ByteBrew Purchase is valid");
                // Reward user here
            } else {
                Debug.Log("ByteBrew Purchase Message: " + purchaseResultData.message);
            }
        }
    });
#elif UNITY_IOS
    // For Apple the receiptPayload is the base64 encoded ASN.1 receipt
    string iosReceipt = receiptPayload;

    ByteBrew.ValidateiOSInAppPurchaseEvent("Apple App Store", e.purchasedProduct.metadata.isoCurrencyCode, (float)e.purchasedProduct.metadata.localizedPrice, e.purchasedProduct.definition.storeSpecificId, e.purchasedProduct.definition.id, iosReceipt, (purchaseResultData) => {
        if (purchaseResultData.purchaseProcessed) {
            if (purchaseResultData.isValid) {
                Debug.Log("ByteBrew Purchase is valid");
                // Reward user here
            } else {
                Debug.Log("ByteBrew Purchase Message: " + purchaseResultData.message);
            }
        }
    });
#endif

    return PurchaseProcessingResult.Complete;
}
```

**Remote Configs**
```csharp
// source: https://docs.bytebrew.io/sdk/unity#RemoteConfigs&A/BTests
// Gotcha: The SDK must be initialized before calling Remote Configs updated.
// To correctly check for initialization call: https://docs.bytebrew.io/sdk/unity#InitializationCallback
// It is not recommended to wait your entire game on the initialization. You should build a polling 
// mechanism to check for the initialization or they can do a WaitUntil, but make sure to exit 
// after 2-3 seconds so your game does not experience a memory leak.

float InitTimeoutSeconds = 3f;

IEnumerator LoadRemoteConfigsWithTimeout()
{
    float timer = 0f;

    // Poll IsByteBrewInitialized() every frame; exit as soon as it's true OR after 3s.
    yield return new WaitUntil(() =>
    {
        timer += Time.deltaTime;
        return ByteBrew.IsByteBrewInitialized() || timer > InitTimeoutSeconds;
    });

    if (!ByteBrew.IsByteBrewInitialized())
    {
        Debug.LogWarning(
            $"[ByteBrew] Initialization timed out after {InitTimeoutSeconds}s. " +
            "Falling back to default config values.");
        yield break;
    }

    // SDK is up: ask the server to refresh, then read values from the local cache.
    // Always supply sensible defaults in case the user is in a control group or offline.
    ByteBrew.RemoteConfigsUpdated(() =>
    {
        string difficulty = ByteBrew.GetRemoteConfigForKey("difficulty", "normal");
        string bossHealth = ByteBrew.GetRemoteConfigForKey("boss_health", "1000");

        Debug.Log($"[ByteBrew] Remote configs loaded. difficulty={difficulty}, boss_health={bossHealth}");

        // TODO: apply these values to your game state (e.g. parse boss_health to int, etc.)
    });
}
```

---

### Unity Advanced Patterns & Antipatterns

**Antipattern: do not wrap the ByteBrew GameObject in your own MonoBehaviour**
```csharp
// source: clarification - common Unity integration antipattern observed in the wild
// Gotcha: The ByteBrew GameObject created via Window -> ByteBrew -> Create
// ByteBrew GameObject is a managed prefab. It already handles its own
// lifetime, including DontDestroyOnLoad across scene loads. You do NOT need
// to write a singleton MonoBehaviour that:
//   (1) re-applies DontDestroyOnLoad to that GameObject,
//   (2) owns an Instance static field, or
//   (3) proxies the SDK's static methods through instance helpers like
//       MyByteBrewManager.Instance.TrackEvent(...).
//
// ByteBrew.InitializeByteBrew, ByteBrew.NewCustomEvent, ByteBrew.SetCustomUserDataAttribute,
// ByteBrew.TrackAdEvent, and the ByteBrewAds.* APIs are all static. Call them
// directly from wherever in your code makes sense -- typically a Loading or
// Launch script for InitializeByteBrew, and inline at the relevant gameplay
// site for event tracking.
//
// Wrapping the SDK in a custom manager adds redundant indirection, duplicates
// the prefab's lifetime management, forces every caller to null-check the
// wrapper, and makes future SDK updates harder to apply.
 
// WRONG -- redundant wrapper that duplicates work the SDK prefab already does
public class ByteBrewManager : MonoBehaviour
{
    public static ByteBrewManager Instance { get; private set; }
 
    private void Awake()
    {
        if (Instance == null) { Instance = this; DontDestroyOnLoad(gameObject); }
        else { Destroy(gameObject); }
    }
 
    private void Start() { ByteBrew.InitializeByteBrew(); }
 
    public void TrackEvent(string name) { ByteBrew.NewCustomEvent(name); }
}
// ...callers then have to do: ByteBrewManager.Instance?.TrackEvent("foo");
 
// RIGHT -- call the static SDK directly from your existing scripts
public class LoadGame : MonoBehaviour
{
    private void Start()
    {
        // The ByteBrew prefab persists itself; we just call the static init.
#if UNITY_IOS && !UNITY_EDITOR
        ByteBrew.requestForAppTrackingTransparency((status) =>
        {
            ByteBrew.InitializeByteBrew();
            ByteBrewAds.InitializeAds();
        });
#else
        ByteBrew.InitializeByteBrew();
        ByteBrewAds.InitializeAds();
#endif
    }
 
    public void StartNewGame()
    {
        ByteBrew.NewCustomEvent("new_game_started"); // static, no wrapper needed
        // ...load scene, reset state, etc.
    }
}
 
public class GameManager : MonoBehaviour
{
    public void TriggerGameOver()
    {
        // Static calls live happily inside whatever class needs them.
        ByteBrew.NewCustomEvent("game_over", new Dictionary<string, string>
        {
            { "final_score", currentScore.ToString() }
        });
        ByteBrew.SetCustomUserDataAttribute("last_score", currentScore);
    }
}
```
*Exception:* a thin MonoBehaviour is still appropriate for things that genuinely need an instance - for example, a dedicated ads-handling script that subscribes to `ByteBrewAds.OnInterstitialAdLoaded` and the other ad event listeners. That class exists to own listener lifetime (subscribe in `Awake`, unsubscribe in `OnDestroy`), not to wrap the SDK. The static `ByteBrew.*` and `ByteBrewAds.*` calls inside it are still called directly, not through a wrapper.

**Where to call `ByteBrewAds.InitializeAds()` when you have a dedicated ads script with other ad-partner SDKs**
```csharp
// source: clarification - co-locate ad-listener subscription with InitializeAds
// Gotcha: If your project has a dedicated ads-handling script -- the name and
// location of this script vary by project (e.g. AdsController.cs,
// MonetizationManager.cs, AdHandler.cs, or whatever your team has called it) --
// call ByteBrewAds.InitializeAds() from THAT script, alongside your other
// ad-SDK initializations such as MobileAds.Initialize(). Do NOT call it from
// the launch/loading script that handles ByteBrew.InitializeByteBrew().
//
// Why: ByteBrewAds.OnAdsInitSuccess (and the other ad listeners) are subscribed
// on the ads script. Subscribing on one script and initializing on another
// introduces script-execution-order risk -- if the loading script's Start runs
// before the ads script has finished its own subscription pass,
// OnAdsInitSuccess fires before anyone is listening and your cross-promo ads
// silently never preload. The bug is invisible at runtime because no exception
// is thrown; ads just don't show.
//
// Co-locating subscription and initialization in the same script removes the
// ordering dependency entirely.
 
// CORRECT -- your dedicated ads script (whatever it's called) owns both the
// listeners AND the InitializeAds call. The class name here is illustrative.
public class YourAdsScript : MonoBehaviour
{
    private void Awake()
    {
        // Subscribe first -- guaranteed to complete before any Start runs.
        ByteBrewAds.OnAdsInitSuccess += OnBBAdsInitSuccess;
        // ... other listeners ...
    }
 
    private void Start()
    {
        MonetizationAds.Initialize(_ => { /* Ads SDK Partner ready */ });
        // ByteBrewAds.InitializeAds lives here, next to MobileAds.Initialize,
        // because the listeners are also here. The OnAdsInitSuccess callback
        // is guaranteed to land on a subscribed handler.
        ByteBrewAds.InitializeAds();
    }
 
    private void OnBBAdsInitSuccess() { /* load cross-promo ads here */ }
}
 
// The launch/loading script only handles ByteBrew core init:
public class LoadGame : MonoBehaviour
{
    private void Start()
    {
#if UNITY_IOS && !UNITY_EDITOR
        ByteBrew.requestForAppTrackingTransparency(_ => ByteBrew.InitializeByteBrew());
#else
        ByteBrew.InitializeByteBrew();
#endif
        // No ByteBrewAds.InitializeAds() here -- that's your ads script's job
        // if you have a separate one.
    }
}
```
*Note:* if you have no dedicated ads script (you're only using ByteBrew analytics with no ads at all), calling `ByteBrewAds.InitializeAds()` from your loading script next to `ByteBrew.InitializeByteBrew()` is fine and correct - there's nothing to co-locate with. The co-location rule only matters when someone else owns the ad-event subscriptions.

### iOS SDK (Swift)
- [iOS SDK Overview](https://docs.bytebrew.io/sdk/ios): Integrate the ByteBrew Swift SDK with native iOS apps and games.

The iOS SDK follows the same conceptual model as Unity: initialize once at app launch, optionally inside the ATT callback if you're targeting iOS 14+, then call event-tracking, custom-data, ad-event, and IAP-validation methods directly. Refer to the docs page for verbatim Swift method names and platform requirements.

### Android SDK
- [Android SDK Overview](https://docs.bytebrew.io/sdk/android): Integrate the ByteBrew SDK with native Android apps and games.

The Android SDK follows the same conceptual model as Unity: initialize at app launch (typically in `Application.onCreate` or your launcher Activity), then call event-tracking, custom-data, ad-event, and IAP-validation methods directly. The Google License Key configured in App Settings is what enables server-side validation against Play Store receipts. Refer to the docs page for verbatim Kotlin/Java method names.

### Godot SDK
- [Godot SDK Overview](https://docs.bytebrew.io/sdk/godot): Integrate ByteBrew with your Godot project.

**Initialize**
```gdscript
# source: https://docs.bytebrew.io/sdk/godot (current Godot SDK init signature)
if OS.get_name() == "Android":
    ByteBrew.InitializeByteBrew("ANDROID GAME ID", "ANDROID GAME KEY", Engine.get_version_info(), "YOUR GAME VERSION HERE ex(0.0.1)")
elif OS.get_name() == "iOS":
    ByteBrew.InitializeByteBrew("IOS GAME ID", "IOS GAME KEY", Engine.get_version_info(), "YOUR GAME VERSION HERE ex(0.0.1)")
```

### GameMaker SDK
- [GameMaker SDK Overview](https://docs.bytebrew.io/sdk/gamemaker): Integrate ByteBrew into your GameMaker projects.

### Flutter SDK
- [Flutter SDK Overview](https://docs.bytebrew.io/sdk/flutter): Integrate ByteBrew into your Flutter mobile apps.

### React Native SDK
- [React Native SDK Overview](https://docs.bytebrew.io/sdk/react-native): Integrate ByteBrew into your React Native projects.

### Unreal SDK
- [Unreal SDK Overview](https://docs.bytebrew.io/sdk/unreal): Integrate ByteBrew into your Unreal Engine games.

### .NET MAUI SDK
- [.NET MAUI SDK Overview](https://docs.bytebrew.io/sdk/netmaui): Integrate ByteBrew into your .NET MAUI cross-platform apps.

### Cordova SDK
- [Cordova SDK Overview](https://docs.bytebrew.io/sdk/cordova): Integrate ByteBrew into your Cordova hybrid apps.

### JavaScript SDK (Web)
- [JavaScript SDK Overview](https://docs.bytebrew.io/sdk/javascript): Integrate ByteBrew into your web games and applications.

**Initialize**
```js
// source: https://docs.bytebrew.io/sdk/javascript
import { ByteBrew } from "bytebrew-web-sdk";
// Initialize the ByteBrew SDK
ByteBrew.initializeByteBrew('WEB_APP_ID', 'WEB_SDK_KEY', 'APP_VERSION_HERE');
```

**Track event**
```js
// source: https://docs.bytebrew.io/sdk/javascript
//Basic Custom Event without any sub-parameters
ByteBrew.newCustomEvent("eventName");

//Basic Custom Event with a sub-parameter
ByteBrew.newCustomEvent("test_sub_param_event", { "test_key": "HelloWorld" });
```

## Ads Dashboard

ByteBrew Ads is the **Grow** product - an AI-layered cross-promotion network for scaling app portfolios with performance-targeted growth. It is powered by **Ctrl**, the AI behavioral targeting engine, and **Alt**, the AI vision engine for creatives. Built-in self-reporting attribution measures campaign performance automatically.

### [Ads Dashboard Overview](https://docs.bytebrew.io/adsdashboard/adsdashboardgeneral)
Hub for all ByteBrew Ads resources. From here, developers can navigate to Create Campaigns (launch new campaigns), Manage Campaigns (manage live campaigns), Campaigns (see all running campaigns), Ad Units (create the ad units that run in apps), Creatives (manage creative assets), Finance (view billing and earnings), and Performance (break down and analyze campaign performance). The dashboard supports Acquisition, Cross-Promotion, LTV, and Retention campaign types.

### [Create Campaigns](https://docs.bytebrew.io/adsdashboard/createcampaigns)
Launch new campaigns. Supports global or regional targeting, multiple campaign objectives (Acquisition, Cross-Promotion, LTV powered by Ctrl, Retention powered by Ctrl), and ad type selection tailored to fit existing ad slots.

### [Manage Campaigns](https://docs.bytebrew.io/adsdashboard/managecampaigns)
Edit, pause, resume, and adjust live campaigns after launch.

### [Campaigns](https://docs.bytebrew.io/adsdashboard/campaigns)
A unified view of every running campaign across the apps in your studio account.

### [Performance](https://docs.bytebrew.io/adsdashboard/performance)
Break down and analyze campaign performance using built-in platform tools. Self-reporting attribution is embedded at the core of the system so performance measurement is automatic.

### [Creatives](https://docs.bytebrew.io/adsdashboard/creatives)
Upload and manage creative assets. Alt, the AI vision engine, evaluates creatives and dynamically serves the variant most likely to drive engagement.

### [Ad Units](https://docs.bytebrew.io/adsdashboard/adunits)
Create the interstitial and rewarded ad units that ByteBrew Ads will deliver into apps. These ad unit IDs are passed to `ByteBrewAds.LoadInterstitialCrossPromoAd`, `ByteBrewAds.LoadRewardedCrossPromoAd`, and the related show/check APIs in the SDK.

### [Finance](https://docs.bytebrew.io/adsdashboard/finance)
The Finance dashboard shows billing, spend, and earnings related to ByteBrew Ads.

**Pro Tip:** To get the most out of Monetization across the platform, integrate both in-app purchases (with server-side validation) and impression-level in-app ad revenue events in your game. The same SDK call that tracks impression revenue feeds the Monetization Overview, Revenue Reports, and LTV dashboards.

## App Dashboard

The App Dashboard is the home of the **Analyze** and **Operate** products. Every chart streams in real-time - there is no wait period after SDK events fire. All data operates in UTC. Historical queries go back 24 months. Every chart can be exported as CSV via the three-dot menu on the chart.

### Analytics

#### [Engagement](https://docs.bytebrew.io/dashboard/analytics)

Located under the Analytics tab, ByteBrew's Engagement Dashboard is the fastest way to learn how users are engaging with an app or game by analyzing vital performance metrics in real-time. All charts on the Engagement dashboard are filterable using the extensive dashboard Filters.

**Popular Use Case:** Applying filters for running A/B Tests or Monetizing users on the Engagement dashboard is a powerful way to measure how different cohorts of players each engage with the game.

**Required to Start using Engagement**
To start using the Engagement Dashboard, the ByteBrew SDK must first be initialized in the game. Initializing the SDK is only one line of code.

**Engagement Charts**

| Chart | Description |
| --- | --- |
| New Users | Daily metric for how many new users have played the game on an individual day. New users are only counted on the very first time they play. |
| DAU | Daily Active Users - distinct users who played within a 24-hour period. Multiple sessions in one day count as 1 DAU. |
| Sessions | Total count of sessions on a daily basis. A user returning 5 times in one day shows as 5 sessions. |
| Session Length | Average session length per day, calculated by summing player playtime and dividing by sessions played. |
| Playtime | Average playtime per user per day, calculated by summing playtime and dividing by users. |
| Geo | Number of users from the top 5 countries on a daily basis. |
| Retention Chart | Daily user retention up to 7 days as a visual graph. |
| Retention Heatmap | Daily user retention up to 7 days in heatmap format. |

**FAQs:** Data shows up in real-time (seconds after events fire). Historical queries go back 24 months. Timezone is UTC. If no data appears, recheck the SDK integration.

#### [Retention Analytics](https://docs.bytebrew.io/dashboard/retention)

Located under the Analytics tab, Retention Analytics gives a unique view of player performance by breaking down player KPIs against each day they come back to play. All charts on the Retention Analytics dashboard are filterable using the extensive dashboard Filters.

**Popular Use Case:** Use Retention Analytics to determine whether the game is building player loyalty by viewing how different retaining cohorts behave.

**Retention Analytics Charts**

| Chart | Description |
| --- | --- |
| Daily Retention Chart & Heatmap | Daily user retention up to 30 days as a graph and heatmap. |
| Session Length by Retention Chart & Heatmap | Daily average session length broken down by each day users return. |
| Session Count by Retention Chart & Heatmap | Average sessions per user broken down by each day users return. |
| Playtime by Retention Chart & Heatmap | Daily average playtime per user broken down by each day users return. |
| Cumulative Playtime by Retention Chart & Heatmap | Total summed playtime by retention day (e.g. Day 4 cumulative = sum of Day 0–4 playtime). |

**Timespan Settings**

- Days: 7, 14, 28, 30, 60, 90, 180, 365, Custom
- Weeks: 4, 8, 16, 24, 32, 46, 52, Custom
- Months: 2, 4, 8, 12, Custom

### Monetization

#### [Monetization Hub](https://docs.bytebrew.io/dashboard/monetization)
Landing page linking the three monetization tools - Overview (high-level metrics), LTV (real lifetime value), and Revenue Reports (custom breakdowns). To get the most out of Monetization, integrate both in-app purchases and in-app ad revenue events.

#### [Monetization Overview](https://docs.bytebrew.io/dashboard/monetizationoverview)

ByteBrew's Monetization Overview connects to all revenue sources to track, validate, and analyze how an app monetizes. It tracks and validates IAPs and also tracks impression-level ad revenue. Both Purchase Events and Ad Events are sent in real-time.

**Required Integrations table:**

| Monetization Channels | Required Integrations |
| --- | --- |
| Both In-App Purchases & In-Game Ads | 1. Integrate ByteBrew SDK<br>2. Implement Purchase Validation (or Purchase Tracking)<br>3. Implement Ad Events to stream impression-level revenue |
| Only In-App Ads | 1. Integrate ByteBrew SDK<br>2. Implement Ad Events |
| Only In-App Purchases | 1. Integrate ByteBrew SDK<br>2. Implement Purchase Validation (or Purchase Tracking) |

**Important:** For purchase tracking, input the Apple App Shared Secret or Google License Key on the App Settings page. For ad events, send revenue in USD and test the output value before going live.

**Monetization Overview Charts**

| Chart | Description |
| --- | --- |
| Total Revenue | Daily total revenue from all sources (Purchase + Ad). |
| IAP Revenue | Daily IAP revenue. |
| Ad Revenue | Daily ad revenue. |
| ARPDAU | Average Revenue Per Daily Active User combining all revenue sources. Split by Ads vs Purchases under Revenue Reports. |
| ARPU | Average Revenue Per User combining all revenue sources. |

**FAQs:** Refunds are not tracked by ByteBrew. Historical queries go back 24 months. Timezone is UTC.

#### [Revenue Reports](https://docs.bytebrew.io/dashboard/monetizationrevenuereports)

Located under the Monetization tab, Revenue Reports lets developers pick and choose vital revenue KPIs in one dashboard. Build a customized table from specific revenue sources to track monetizing performance.

**Building a Revenue Report:**

1. Select "Step Report" to open the Report Settings
2. Select the revenue events to analyze
3. **Optional:** Choose up to 2 breakdowns
4. Choose the metrics to query:

Available metrics:

- **ARPDAU** - Average revenue per daily active user (all sources)
- **Ad ARPDAU** - Average revenue per daily active user (ad events only)
- **IAP ARPDAU** - Average revenue per daily active user (purchases only)
- **Revenue** - Total revenue (all sources, or just ads, or just purchases)
- **Ad Revenue** - Total revenue from ad events only
- **ARPU** - Average Revenue Per User from all sources
- **ARPPU** - Average Revenue Per Purchasing User (when only Purchases selected)
- **Purchases** - Number of purchases that occurred
- **Purchase Conversion Rate** - Purchases ÷ total users
- **Ad Impressions Per User** - Average impressions per user
- **Ad eCPM** - Average eCPM from ad events

Metrics auto-filter based on the events selected - if Ad Events are deselected, Ad eCPM disappears from the list. The chart visualizes the top 3 breakdown values; the datatable shows all values. Save Filters and Load Filters persist across studio users.

#### [LTV](https://docs.bytebrew.io/dashboard/monetizationltv)

Located under the Monetization tab, LTV calculates the real cohorted lifetime value of users using each of an app's revenue events. LTVs are filterable using the extensive dashboard Filters.

**Popular Use Case:** Measure the real lifetime value of different user segments with both IAP and ad revenue events, and predict LTV at later retention stages.

**Setting up an LTV query:**

1. **Select revenue events (up to 3).** Three event types are supported:
   - **Purchase Events** - The dashboard auto-routes the "revenue" and "currency" parameters.
   - **Ad Events** - The dashboard auto-routes the "revenue" parameter and assumes USD.
   - **Custom Events** - You must assign specific "revenue" and "currency" parameters. If no currency is selected, values are treated as USD.

2. **Timespan Settings:**
   - Days: 7, 14, 28, 30
   - Weeks: 2, 3, 4

3. **Breakdown By:** Date (default), Build, OS, GEO.

4. **LTV Prediction (optional):** Check "Show Prediction" to enable a forecasted fitted LTV curve based on a **logarithmic regression model**. Prediction windows:
   - Days: 7, 14, 28, 30, 60
   - Weeks: 2, 3, 4, 8

**Why logarithmic regression?** During comparative testing on live data, logarithmic regression curves produced the best prediction models, as they most accurately fit the natural curved deceleration observed over time for user engagement.

**Outputs:** an LTV Graph (line graph of average values, with a "Show Breakdown" toggle to split by rows) and an LTV Datatable (Breakdown column + Total Users + LTV Value cells).

### Live Ops

#### [Remote Configs](https://docs.bytebrew.io/dashboard/remoteconfig)

One of ByteBrew's most powerful Live Ops features. Remote Configs lets developers send updates to players' devices in milliseconds without shipping new app store builds.

**Limits:** Each app has a max of **250 Remote Configs**, and a max of **50 Conditional Remote Configs**.

**Popular Use Case:** Remotely deploy game updates without waiting on app store review. Fix player experiences, change level difficulty, adjust sale prices, or automate Grouped Configs to rotate on a set time interval (e.g. daily in-game shop sales).

**Required Integrations:** The ByteBrew SDK must be initialized AND Remote Configs must be implemented in game code wherever updates might be needed. **Best practice:** implement more Configs than seem necessary - it's easier to have them and not use them than to ship a build and realize you need one.

**Three Config Types:**

1. **Single** - straightforward key/value pair with a Start Date (YYYY-MM-DD) and optional End Date. When the start date activates, all players receive the config immediately.
2. **Conditional** - same as Single but also requires selecting a Condition; only matching users receive the config.
3. **Group** - multiple key/value pairs that rotate automatically. Great for automated daily sales.

#### [A/B Tests](https://docs.bytebrew.io/dashboard/abtesting)

ByteBrew's A/B Testing platform splits users into variant groups to test hypotheses against game performance. A/B Tests **use Remote Configs to operate** - they must be implemented during SDK integration for testing to work.

**Popular Use Case:** Increase player engagement by tracking how different user buckets retain and reach vital conversion events.

**Setup stages:**

1. **Details:** Test Name, Test ID, Start Date, End Date (optional).
2. **Filters (optional):** Country, Build, OS, and other user filters. **Filter settings cannot be edited after the test is created.**
3. **Groups:** Define variant groups and user split percentages.
4. **Goals:** Define the conversion events the test measures.

### Custom Workspace

#### [Custom Workspace Overview](https://docs.bytebrew.io/dashboard/customworkspace)
Hub linking the four custom-analytics tools: Funnels, Breakdowns, Cohorts, and Mechanics. All four require the ByteBrew SDK initialized and custom events integrated in the game.

#### [Funnels](https://docs.bytebrew.io/customworkspace/customfunnels)

Located under the Custom Workspace tab, Custom Funnels uses tracked custom events to build real-time visual breakdowns of player flow through every part of the game. Build funnels up to **20 steps** in real-time.

**Popular Use Case:** Visualize drop-off paths for tutorial steps, purchase conversions for different cohorts, and transitions of users through game stages.

**Setting up a Funnel:**
1. Add the first Funnel Step and choose the event from the dropdown.
2. **Optional:** add subparameter filters for that step.
3. Repeat for up to 20 steps. Use the clone icon to duplicate steps quickly.

**Funnel Breakdowns:** Split each step on the output graph by a chosen breakdown dimension.

**Tip:** Tracking subparameters under each custom event unlocks much deeper funnel analysis.

#### [Breakdowns](https://docs.bytebrew.io/customworkspace/custombreakdowns)

Located under the Custom Workspace tab, Custom Breakdowns expands one custom event by the subparameter values tracked under it for hyper-granular engagement metrics.

**Popular Use Case:** Deep-dive into how players interact with custom events by analyzing a granular table of engagement metrics.

**Setting up a Breakdown:**
1. Choose the custom event from the Event dropdown.
2. **Optional:** add subparameter filters. *Avoid filtering by a subparameter and also grouping by the same subparameter.*
3. Use "Add Group By" to choose dimensions to break the event by in the output datatable.
4. **Optional:** add Aggregates to compute calculated values in the datatable.

**Aggregate functions:** Average, Median, Sum, Min, Max. Aggregates can be applied to the event's value or to any tracked subparameter (e.g. averaging "AmountSpent" inside a "VirtualCurrencyPurchase" event).

#### [Cohorts](https://docs.bytebrew.io/customworkspace/customcohorts)

Located under the Custom Workspace tab, Cohorts plots when different cohorts of players interact with each part of the game by seeing how users transition from one event to another.

**Popular Use Case:** Map how players transition from one custom event to another. For example, from "User Install" to a powerup event like "Fireball" - answers questions like "at what time do players start using particular powerups or characters?"

**Setting up a Cohort:**
1. Select a **Start Event** (custom or auto-tracked).
2. **Optional:** add subparameter filters on the start event.
3. Select an **End Event** (custom or auto-tracked).
4. **Optional:** add subparameter filters on the end event.
5. **Optional:** Breakdown By (default Date).
6. **Optional:** Aggregate By to output a calculation using the chosen events.

#### [Mechanics](https://docs.bytebrew.io/customworkspace/custommechanics)

Located under the Custom Workspace tab, Mechanics is the developer's data playground - build custom queries combining events, segments, breakdowns, formulas, and chart types. Any kind of analysis is possible.

**Popular Use Case:** Accomplish any kind of data analysis you can imagine, build segments to examine how different user groups interact, and visualize the query exactly as desired.

**Building a Mechanic query:**
1. Set up Events to analyze.
2. Create Segments of users and link them to events.
3. **Optional:** choose a Breakdown.
4. **Optional:** build a formula using selected Events.
5. Select the chart type to visualize.

**Event setup options:** choose the event, optionally add subparameter filters, optionally add an aggregate. Aggregate functions include Count (default), Unique (unique values per user), Average, and Subparameter Aggregation (aggregate by a subparameter value).

### Journeys

#### [Journeys](https://docs.bytebrew.io/dashboard/journeys)

Journeys visualizes every path players take through a game to reach vital events.

**Popular Use Case:** Understand how players transition through every path by examining custom events. Common scenario: if a Custom Funnel shows a drastic drop between Step 3 and Step 4, make a Journey out of those two steps to see why players are falling off and where they go instead.

**Setting up a Journey:**
- Enable a **Start Event** and/or an **End Event** (you don't need both - using one enables drop-off visibility).
- Optionally add subparameter filters on each event.
- **Add Segments:** create a user segment to refine which users the Journey includes.

**Tip:** If a Journey uses only one Start or End Event (not both), the dashboard surfaces user Dropoffs in the journey path.

### Push Notifications

- [Push Notifications Overview](https://docs.bytebrew.io/dashboard/pushnotifications): Design, automate, and deliver cross-platform push campaigns globally or to specific user cohorts.
- [Add Push App](https://docs.bytebrew.io/pushdashboard/addapp): Register an app to start sending push.
- [Setup Push App](https://docs.bytebrew.io/pushdashboard/settings): Upload APNs/FCM credentials.
- [Create Segment](https://docs.bytebrew.io/pushdashboard/segments): Build user segments to target.
- [Create Notifications](https://docs.bytebrew.io/pushdashboard/notifications): Compose and schedule notifications.
- [Push Users](https://docs.bytebrew.io/pushdashboard/users): View opted-in users and tokens.
- [Push Analytics](https://docs.bytebrew.io/pushdashboard/analytics): Track delivery, open, and conversion metrics.

### Attribution

#### [Attribution Dashboard](https://docs.bytebrew.io/dashboard/attribution)

ByteBrew offers **100% free attribution measurement** with all integrated network partners. The Attribution Dashboard shows a high-level real-time visualization of advertising performance metrics. All Attribution and SKAN charts operate in UTC.

**Popular Use Case:** Use attributed user data inside filters across every other dashboard for deep analytic views into converting users - attribution data isn't siloed; it flows into Engagement, Retention, LTV, Funnels, and everything else.

**Required:** ByteBrew SDK initialized AND attribution networks set up on the Network Settings dashboard.

**Attribution Overview Charts:**

| Chart | Description |
| --- | --- |
| Non-Organic Installs | Daily count of converted installs by network. |
| Spend | Daily tracked spend by network. |
| Impressions | Daily tracked impressions by network. |
| Clicks | Daily tracked clicks by network. |
| CTR | Click-through rate - % of impressions that result in clicks. |

#### [Attribution Breakdowns](https://docs.bytebrew.io/dashboard/attributionbreakdowns)

Located under the Attribution tab, Attribution Breakdowns analyzes user-acquisition campaign performance across key marketing metrics.

**Available metrics:**

- **Impressions** - tracked count of impressions
- **Clicks** - tracked count of clicks
- **CVR** (Conversion Rate) - % of clicks that result in an install
- **CTR** (Click-through Rate) - % of impressions that result in clicks
- **eCPI** - effective cost per install
- **Spend** - total spend reported by campaigns
- **IPM** - impressions per mille
- **Impressions Per Install** - average number of impressions per install

By default all metrics populate in the datatable; use the Breakdowns dropdown to group results.

#### [SKAN Attribution](https://docs.bytebrew.io/dashboard/skanattribution)
iOS SKAdNetwork attribution measurement.

#### Attribution Setup Pages
- [Network List](https://docs.bytebrew.io/attribution-setup/networks): All supported attribution networks.
- [Google Ads Setup](https://docs.bytebrew.io/attribution-setup/attribution-googleads)
- [Apple Search Ads Setup](https://docs.bytebrew.io/attribution-setup/attribution-applesearchads)
- [Unity Ads Setup](https://docs.bytebrew.io/attribution-setup/attribution-unityads)

## APIs

### [ALE Metrics API](https://docs.bytebrew.io/services/ale)
Pull aggregate ByteBrew metrics programmatically for external dashboards or data pipelines.

### [Push API](https://docs.bytebrew.io/pushdashboard/api)
Programmatically schedule and send push notifications.

## Video Tutorials

### [How to integrate ByteBrew Unity SDK in 5 Minutes!](https://youtu.be/PZ9hLFJlBnM)
Covers Unity SDK / Setup. Step-by-step tutorial on downloading the Unity SDK from GitHub, importing it, setting up the App ID and SDK Key in the inspector, and writing the initialization script.

**Video transcript highlights:**
- `00:20` - Dashboard Setup: adding a new game in the dashboard, defining app title, bundle identifier, etc.
- `00:46` - Game Keys: retrieving the generated Game ID and SDK Key from app settings.
- `01:17` - Unity Import: importing the `.unitypackage` custom package from the GitHub download.
- `01:31` - Unity Configuration: Window -> ByteBrew -> Create ByteBrew GameObject in the first (launch) scene to capture accurate session lengths and play times. Then go to ByteBrew settings.
- `01:58` - Adding Keys: enabling Android/iOS settings and pasting the Game ID and SDK Key into the inspector.
- `02:48` - Initialization: calling `ByteBrew.InitializeByteBrew()` inside a loading script `#if UNITY_ANDROID` block.
- `03:50` - App Tracking Transparency (ATT): handling the iOS 14 prompt using `ByteBrew.requestForAppTrackingTransparency` and initializing *inside* the callback so events are tagged correctly.
- **Gotcha:** Always initialize ByteBrew in your very first "Launch" scene so metrics like play times, session lengths, and new user events are tracked cleanly.

### [In-App Purchase Tracking with Receipt Validation](https://youtu.be/Z18FClrIdTc)
Covers Unity SDK / Monetization. Shows how to track basic in-app purchases and optionally use the robust server-side receipt validation callback to weed out fraudulent transactions.

**Video transcript highlights:**
- `01:00` - Basic tracking: demonstrates basic IAP tracking with `ByteBrew.TrackGoogleInAppPurchaseEvent()` and `ByteBrew.TrackiOSInAppPurchaseEvent()`.
- `03:00` - Receipt validation: ByteBrew hits the App Store / Play Store servers to validate the payload.
- `05:20` - Callbacks: `ByteBrew.ValidateiOSInAppPurchaseEvent()` returns `purchaseResult.isValid` to determine whether to actually deliver the item to the user's inventory.
- **Gotcha:** Do not reward users for purchases until the receipt is explicitly validated as true via the validation callback. Make sure the receipt payloads are perfectly extracted into JSON string formatting.

### [Server-Side Purchase Validation in Unity](https://www.youtube.com/@bytebrew)
Covers Unity SDK / Monetization. Deep dive into extracting the raw receipt JSON strings correctly from Unity's `ProcessPurchase` callback using `MiniJson` prior to sending the validation payloads to ByteBrew. (Note: short URL pending verification on the ByteBrew channel.)

**Video transcript highlights:**
- `01:00` - Deserializing the Payload: `MiniJson.JsonDecode(e.purchasedProduct.receipt)` directly inside `ProcessPurchase` to target the "Payload" key.
- `01:15` - Android Extraction: running `MiniJson` a second time on the Android payload string to fetch the exact `"json"` and `"signature"` values necessary for Google Play validation.
- `01:45` - iOS Extraction: the base iOS payload is already the Base64-encoded ASN.1 receipt.
- `02:00` - Calling Validation: feeding those exact strings into `ByteBrew.ValidateGoogleInAppPurchaseEvent` or `ByteBrew.ValidateiOSInAppPurchaseEvent` and awaiting the `purchaseResultData.isValid` response.
- **Gotcha:** Failing to deserialize the Unity IAP string into proper JSON will cause server validation to fail, returning `isValid = false` with a specific JSON parsing error message.

### [Remote Configs + A/B Testing](https://youtu.be/CfipoK2B7rI)
Covers App Dashboard / Live Ops. How to set up remote configs for single values (e.g. boss health) and create full A/B test groups for features like button color variants.

**Video transcript highlights:**
- `01:00` - Remote Configs Dashboard: creating a config key in the ByteBrew Live Ops dashboard (e.g., changing game difficulty parameters dynamically).
- `02:30` - A/B Testing Dashboard: setting up a test by assigning percentages of users (e.g. 50%) to different variants to test configurations like button colors.
- `04:15` - Fetching Configs: how to parse the string value returned from the remote config and apply it to a local integer for difficulty.
- `06:12` - Evaluating A/B Variants: re-checking the key in code so users seamlessly receive their A/B group variant if they are assigned one.
- **Gotcha:** Default values should be handled natively in code in case a user is placed in the Control Group or lacks internet connectivity. The SDK must also be fully initialized prior to fetching configurations.

### [Engagement Dashboard tour](https://www.youtube.com/watch?v=5rIy-Pf1_xU)
Walkthrough of the real-time Engagement Analytics dashboard.

### [Retention Analytics tour](https://www.youtube.com/watch?v=WEUYOYdlefo)
Walkthrough of the Retention Analytics dashboard, including timespan settings and heatmaps.

### [Remote Configs overview](https://www.youtube.com/watch?v=-hDxbQC608U)
Overview of Single, Conditional, and Grouped configs and how they ship live updates without an app store release.

### [A/B Testing overview](https://www.youtube.com/watch?v=l-Pd-rNrmlk)
Overview of the A/B Tests dashboard - variant groups, filters, goals, and analyzing results.

### [Custom Funnels](https://www.youtube.com/watch?v=xqFh2q_-h_4)
How to build up to 20-step real-time funnels with custom events and subparameters.

### [Custom Breakdowns](https://www.youtube.com/watch?v=HBmBZr2Z55o)
How to group and aggregate custom-event subparameters in the Breakdowns dashboard.

### [Custom Cohorts](https://www.youtube.com/watch?v=LUHyxEZhi7I)
How to plot user transitions between start and end events with optional subparameter filters.

### [Mechanics + Revenue Reports](https://www.youtube.com/watch?v=qzrty59M1s4)
How to build custom queries with events, segments, breakdowns, and formulas.

### [ByteBrew YouTube Channel](https://www.youtube.com/@bytebrew)
All ByteBrew video tutorials.

## Optional

- [Contact Us](https://docs.bytebrew.io/BBSettings/contactus): Support contact form.
- [Book Demo](https://calendly.com/bytebrew-success/bytebrew-demo-walkthrough): Schedule a walkthrough with the ByteBrew team.
- [Terms of Service](https://docs.bytebrew.io/BBSettings/termsservice): Platform terms.
- [Privacy Policy](https://docs.bytebrew.io/BBSettings/privacypolicy): Privacy policy.
- [Ad Network Terms](https://docs.bytebrew.io/BBSettings/adsterms): Ad network terms and conditions.
- [GitHub: ByteBrewIO](https://github.com/ByteBrewIO/): Open-source SDKs and sample projects.