# Three In-Game Experiences Powered by Almedia Link
Source: https://almedia-c3396e23.mintlify.app/overview/experiences
Link, Rewarded Progression, and Offers — the three native in-game surfaces Almedia Link adds for players and publishers, without leaving the game.
Almedia Link adds three native in-game surfaces. Each one is designed to feel like it belongs in the game — not like a third-party widget. The player never leaves the app: the linking flow runs in a secure native webview, and the reward hub and offers catalog open in the same way.
A native popup invites the player to link their Freecash account. The offer is clear and concrete: a sign-up bonus on Freecash **plus** an in-game reward set by the publisher. Colors, copy, and CTA label are all configurable via **Almedia → Settings** in Unity — no code changes required, and no Prefab Variant needed for text and color adjustments.
The linking flow itself runs in a secure native webview; the SDK manages the browser surface entirely. When the player completes linking, `OnLinkCompleted` fires on the Unity main thread — use it for celebration UX, a one-time analytics event, or unlocking a tutorial step.
The `LinkButton` prefab handles the full flow automatically: it shows when the player is eligible, opens the popup on tap, and hides itself once the player has linked. Drop it into a Canvas and you're done.
The Reward Hub is a native in-game screen that shows linked players what they've earned on Freecash and what's coming next — without ever leaving the game. It's a webview surface managed by the SDK, opened with a single call:
```csharp theme={null}
AlmediaLinkSDK.ShowRewardHub();
```
Alternatively, use the bundled `LinkButton` prefab — once a player is linked, the same button automatically routes to the Reward Hub instead of the linking popup. No branching logic in your code.
The Reward Hub cuts churn by keeping engaged, linked players informed about their progress. Players who can see their earnings have a reason to return.
The Offers screen is the paid-action catalog: linked players complete tasks — install other games, reach milestones, hit spending thresholds — to earn more rewards on Freecash. This is the main driver of ongoing CPA revenue for publishers. Open it with:
```csharp theme={null}
AlmediaLinkSDK.ShowOffer();
```
Offer availability is transient — an offer that exists now may be gone after the next sync, and new ones can appear. The call is always safe: when no offer is available, it no-ops and logs the reason. Don't cache availability state; let the SDK handle the routing.
## Lifecycle summary
All three surfaces fire `OnScreenPresented` when they open and `OnScreenDismissed` when they close. Wire these two events to pause and resume your game — the SDK guarantees a matched pair for every screen that actually appears. A call that opens nothing (wrong state, no offer available, another screen already open) fires neither event.
How CPA revenue flows from offers completions to your publisher account.
Install the SDK, add your key, and drop a prefab — 15 minutes to first link.
# Get Started with Almedia Link: First Link in 15 Minutes
Source: https://almedia-c3396e23.mintlify.app/overview/get-started
Fastest path from zero to a working Almedia Link integration — install the SDK, add your key, drop a prefab. Agent-friendly. Done in 15 minutes.
This is the fastest path to a working Almedia Link integration. You need a Unity project (2022.3 LTS or later) and an integration key from your Almedia integration manager. A coding agent can complete this integration using the SDK repo and the key alone — no other context required.
**Agent-friendly path:** hand this page plus the SDK repo URL (`https://github.com/almedia-tm/almedia-link-sdk`) and your integration key to a coding agent. It can complete the integration from those two inputs.
Contact your Almedia integration manager. They issue a separate key for iOS and a separate key for Android — you need both if you're shipping on both platforms.
Store keys securely. The `AlmediaLinkSettings.asset` file that holds them is committed to your project by default — treat it as semi-sensitive and do not push it to a public repo.
In Unity: **Window → Package Manager → + → Add package from Git URL**. Paste:
```
https://github.com/almedia-tm/almedia-link-sdk.git
```
To pin a specific version, append `#vX.Y.Z`:
```
https://github.com/almedia-tm/almedia-link-sdk.git#v1.1.4
```
After the package imports, open **Almedia → Settings** and enter your iOS and Android integration keys in the **SDK Configuration** section. The `AlmediaLinkSettings.asset` is created automatically on first import — you'll see it at `Assets/AlmediaLink/Resources/`.
Create a MonoBehaviour that calls `AlmediaLinkSDK.Initialize` in `Awake`. Subscribe to events before calling `Initialize` so you don't miss the first `OnStatusChanged` transition.
```csharp AlmediaBootstrap.cs theme={null}
using UnityEngine;
using AlmediaLink;
using AlmediaLink.Models;
public class AlmediaBootstrap : MonoBehaviour
{
void Awake()
{
AlmediaLinkSDK.OnStatusChanged += status => Debug.Log($"Almedia status: {status}");
AlmediaLinkSDK.OnLinkCompleted += linkedAt => Debug.Log($"Linked at {linkedAt}");
AlmediaLinkSDK.OnErrorOccurred += err => Debug.LogError($"Almedia error: {err.Code}");
AlmediaLinkSDK.Initialize(new AlmediaLinkConfig
{
// Android requires at least one of: Gaid, Asid, Oaid, AdjustDeviceId, AppsFlyerId
Gaid = "YOUR_GAID",
Idfa = "YOUR_IDFA",
});
}
}
```
Integration keys are read from **Almedia → Settings** automatically — you don't need to pass them in code unless you want a runtime override. Supply the advertising identifiers (`Gaid`, `Idfa`, etc.) from wherever your project resolves them. On Android, at least one device/advertising ID is required for initialization to succeed.
Drag one of the four `LinkButton` prefabs — `LinkButtonA`, `LinkButtonB`, `LinkButtonC`, or `LinkButtonD` — from `Packages/com.almedia.link/Runtime/Resources/Prefabs/` into a Canvas in your scene.
The button manages itself: it appears automatically when the player is eligible to link, routes to the Reward Hub once they're linked, and hides in every other state. No code wiring required. Press **Play** to test it in the editor.
The editor runs a mock bridge automatically — you'll see the full linking flow, status transitions, and reward notifications without a device build. To test non-happy paths (blocked users, network failures, empty notification batches), use `AlmediaLinkEditorMock` in play-mode tests.
iOS ATT, Android Gradle deps, notification customization, error handling, and troubleshooting.
Every public type, method, event, and settings field in the SDK.
# How Almedia Link Revenue Works for Publishers — CPA Model
Source: https://almedia-c3396e23.mintlify.app/overview/how-revenue-works
Publishers earn a share of CPA revenue from linked, engaged players. A factual breakdown of the revenue flow, key metrics, and what drives your results.
When a player links their Freecash account and completes paid actions in the Offers catalog, Almedia earns CPA revenue from the advertisers paying for those completions. Publishers receive a share of that revenue. The linking event is the qualifying gate, and everything downstream depends on it.
## The revenue flow
### The player links
The player taps the Link button, connects their Freecash account, and claims their sign-up bonus. This is the one-time qualifying event. No link, no revenue, which is why link rate is the primary lever to optimize.
### The player completes offers
The linked player works through the Offers catalog: installing other games, reaching progression milestones, hitting spend targets. Each completion triggers a CPA payment from the advertiser to Almedia.
### The publisher earns
The publisher receives a share of the CPA revenue generated by their linked, engaged players. The exact revenue-share rate is agreed with your Almedia integration manager and is not published here. Contact them directly for your rate.
### The player gets a reward notification
As earnings arrive, linked players receive in-game reward notifications via the SDK's notification system. Seeing rewards land keeps players engaged and coming back, which drives more offer completions.
## Key metrics
Across the publisher network, roughly 1 in 7 players who see the link prompt connect their Freecash account.
Linked players show measurably higher retention and engagement compared to unlinked players in the same cohort.
These figures are averages across the publisher network. Your results will vary based on game genre, audience demographics, and integration quality: specifically how prominently the Link button is surfaced, and how early in the player lifecycle it appears.
## What affects revenue
Three variables move the needle: **link rate** (how many eligible players actually connect their account), **offer engagement** (how actively linked players work through the catalog), and **player quality** (the audience's propensity to complete paid tasks). Integration decisions (where the Link button appears, when in the session it's shown, how the in-game reward is positioned) directly affect the first two. The third is a function of your game's genre and audience.
Prerequisites, integration key setup, and what to expect from onboarding.
Fastest path from zero to a working Almedia Link integration.
# The Rewarded Link That Pays Off in 15 Minutes | Almedia
Source: https://almedia-c3396e23.mintlify.app/overview/index
Almedia Link turns players into earners — real cash, gift cards, and in-game rewards for one account link, with a measurable LTV lift for publishers.
Almedia Link turns players into earners — real cash, gift cards, and in-game rewards for one account link. Publishers see an average 15% install-to-link rate and a 10%+ LTV lift for linked users. The SDK drops into any Unity game in about 15 minutes, without changing the game economy or existing UI.
**15 minutes to first link.** The integration is designed to be fast. A coding agent can complete it using the SDK repo plus an integration key — no other context required.
Across the publisher network, roughly 1 in 7 players who see the link prompt connect their Freecash account.
Linked players show higher retention and spend more time in-game as they work through the offers catalog.
Requirements, keys, approval, and what to expect before you go live.
Browse the source, pin a release version, and read the changelog.
## What's in these docs
The one-sentence version, the architecture, and what the SDK is not.
Link, Rewarded Progression, and Offers — the three native in-game surfaces.
The CPA revenue flow, key metrics, and what drives your share.
```text theme={null}
```
# What Is Almedia Link? Rewarded UA for Mobile Games
Source: https://almedia-c3396e23.mintlify.app/overview/what-is-almedia-link
Almedia Link adds one rewarded action — linking a Freecash account — to any Unity game, without touching the game economy or existing UI.
Almedia Link is a lightweight Unity SDK that adds exactly one rewarded action to a mobile game: linking the player's Freecash account from inside the game. Players earn real rewards for linking and for completing offers afterward. Publishers earn a share of the CPA revenue those completions generate. The SDK doesn't require changing the game economy or UI — it drops in alongside whatever the game already does.
## One action, three outcomes
A themable native popup invites the player to connect their Freecash account and claim a sign-up bonus.
Linked players see what they've earned and what's next — an in-game earnings view that keeps them engaged.
A post-link catalog of paid actions (install games, reach milestones) that drives ongoing CPA revenue.
## How it fits in
The SDK is a Unity UPM package (iOS and Android) with zero third-party runtime dependencies on the Unity side. Installation takes a single Git URL in the Package Manager. After that: open **Almedia → Settings**, enter your iOS and Android integration keys, and drop one of the four bundled `LinkButton` prefabs into a Canvas. That's the entire mechanical surface — one settings window, one prefab, one `Initialize` call.
## What it is not
Almedia Link is not a full offerwall, not an ad network, and not a replacement for the game's own monetization. It adds one rewarded action on top of what already exists — the link. Everything else (the offers catalog, reward notifications, the progression view) flows from that single linking event.
Exactly what Link, Rewarded Progression, and Offers look and feel like for the player.
How CPA revenue flows from linked players to publishers, step by step.
# link-best-practices
Source: https://almedia-c3396e23.mintlify.app/publisher/link-best-practices
Pop-up placement, pop-up design, homescreen icon, post-link user flow and a checklist for a high install-to-link rate.
Almedia Link is Freecash account linking for mobile games. This guide covers the patterns behind a high install-to-link rate and a clear lift in LTV for linked users: pop-up placement, pop-up design, homescreen icon, the post-link user flow, and a full checklist you can audit against.
# Link Best Practices
These are the patterns behind a high install-to-link rate, and a clear lift in LTV for linked users. Follow them to see better results.
## 01 · Pop-up placement
Timing alone separates the strongest integrations from the average ones.
VIDEO: screen recording of live gameplay where the pop-up surfaces on its own 2–5 minutes in, mid-session, with no ad before it and no tap from the player.
* Surfaces within the first 2–5 minutes play time
* Force-shown, no tap required
* Re-shown at least every 30 minutes to unlinked players
* Attention is still fresh, so install-to-link peaks
VIDEO: screen recording of a rewarded ad finishing and the pop-up firing the instant it closes.
* Fires straight after a rewarded ad
* Waits for the player to tap something
* Capped to "once per session"
* Player is already fatigued, most never see it twice
Roll it out to at least 90% of users. Small test cohorts hide the effect.
## 02 · Pop-up design
The design of the pop-up should be native to your game, font, style etc. This is just an illustration of the components it should include.
IMAGE: full-screen pop-up in your game's art style, \$10 bonus headline, coin reward icon, one "Earn Rewards" pill CTA.
* Block dismissal of the pop-up for a few seconds
* \$10 bonus stated outright
* In-game currency reward on the banner
* One clear CTA focused on Rewards
* Freecash icon used
IMAGE: small partial banner with stock art, a "Sign Up" button and a second "Check Link" button.
* Partial-screen banner with generic assets
* No reward stated anywhere
* "Sign Up" wording
* Player has to guess the value, so they dismiss it
**Social proof**
* "Join millions of players already earning daily."
* "Join a community of over 80 million players earning real rewards."
**CTA**
* "Earn Rewards"
* "Link Account & Earn Rewards"
* "Get Rewards"
## 03 · Homescreen icon
Most players don't link on the first pop-up, this is what brings them back without interrupting them again.
IMAGE: floating icon in your game's art style with the Freecash mark, a coin reward cue and a red notification dot.
* Carries the Freecash icon
* Reward signal on it: cash, coins or gift
* Draws the eye: notification bubble, animation or colour highlight
* Keep it on screen for anyone who hasn't linked
* Good placements: homescreen corner, or an 'Earn' tab in the shop
IMAGE: generic wallet icon with no Freecash branding and no reward signal.
* Generic wallet or money art, no Freecash mark
* Buried in a settings menu
* Reads as another shop button, so it gets ignored
## 04 · User Flow after linking Full flow needs SDK 1.1+
A visible reward in the first minutes after linking is what turns a linked account into a returning, higher-LTV player.
VIDEO: one continuous screen recording of the real post-link flow: the player returns and sees the in-game reward paid out, then gets nudged to the Freecash icon on the homescreen, then opens Rewarded Progression and sees the daily and play rewards. Real app footage, not a diagram or a flow chart.
On their next return, pay out the in-game reward and show to them that they received it.
Steer them toward the Freecash icon on the homescreen so they know where to find it. Use a short tutorial for it. Point at it once, don't auto-open it, let the user make the press.
Badge the icon with a red "1" on every milestone the user achieves, using a reward notification. [Technical Guide for this](https://github.com/almedia-tm/almedia-link-sdk/blob/main/Documentation~/integration-guide.md#reward-notifications)
## 05 · Checklist
This is the same checklist we use to audit live integrations. If you can tick every box, you're ahead of most publishers we work with.
* [ ] Surfaces within the first 2–5 minutes of play time
* [ ] Force-shown, no tap required
* [ ] Re-shown at least every 30 minutes to unlinked players
* [ ] Never fired straight after a rewarded ad
* [ ] Not capped to once per session
* [ ] Rolled out to at least 90% of users
* [ ] Full-screen and native to your game's art and fonts
* [ ] Dismissal blocked for a few seconds
* [ ] \$10 sign-up bonus stated outright
* [ ] In-game currency reward shown on the banner
* [ ] One clear CTA focused on rewards, no "Sign Up" wording
* [ ] Freecash icon used
* [ ] Includes a social-proof or trust-signal line
* [ ] Freecash icon carried on the button
* [ ] Reward signal (cash, coins or gift) visible on it
* [ ] Draws the eye: notification bubble, animation or colour highlight
* [ ] Placed in the homescreen corner or an 'Earn' tab in the shop
* [ ] Stays on screen for anyone who hasn't linked
* [ ] In-game reward paid out on the player's next return
* [ ] Player is shown that they received the reward
* [ ] Player is nudged toward the Freecash icon once, not auto-opened
* [ ] Rewarded Progression walked through once
* [ ] Icon badged with a red "1" on every milestone via reward notification
***
Test it. Then tell us what happened.
Run your own A/B tests on any of this. If you do, or if you change the design, send us what you learn, so we can keep making this guide better for everyone.
Share your results
# Configure Adjust Attribution for the Almedia Link SDK
Source: https://almedia-c3396e23.mintlify.app/publisher/mmp/adjust
Pass the Adjust device ID to the Almedia Link SDK for accurate install and link-event attribution on both iOS and Android platforms.
Almedia Link uses the Adjust device ID to attribute installs and link events accurately. You need to retrieve the Adjust Device ID at runtime and pass it to the SDK during initialization — this is a one-time setup that your engineering team handles in code, but you need to know what to request and why.
## What to pass
Pass the `AdjustDeviceId` field in `AlmediaLinkConfig` when calling `AlmediaLinkSDK.Initialize`. This is done by your engineering team in code — see the Integration Guide for the full Initialize snippet.
The field name to share with your engineer is `AdjustDeviceId`. It lives inside the `AlmediaLinkConfig` object that gets passed to the SDK at startup. No other Adjust-specific configuration is required.
## How to retrieve the Adjust Device ID
The Adjust SDK exposes a device identifier that your engineer retrieves at runtime — consult your Adjust SDK documentation for the exact method. Your engineer calls it before or during SDK initialization and assigns the result to the `AdjustDeviceId` field. The value is a string unique to each device — it is not a user ID or advertising identifier.
Share the field name `AdjustDeviceId` with your engineer so they know exactly where to slot the value.
## What Almedia does with it
Almedia uses the Adjust device ID to match the linking event back to the original install campaign. When a player links their Freecash account, that event is tied to the install Adjust already recorded. This ensures CPA revenue is attributed correctly to your campaigns and your revenue share reflects your actual traffic — not an approximation.
Do not pass a hardcoded or placeholder value. Attribution will fail silently if the device ID is wrong, resulting in missed revenue. Always retrieve the value at runtime from the Adjust SDK.
Review everything you need in place before going live.
The complete technical walkthrough for your engineering team.
# Configure AppsFlyer Attribution for Almedia Link SDK
Source: https://almedia-c3396e23.mintlify.app/publisher/mmp/appsflyer
Pass the AppsFlyer UID to the Almedia Link SDK so installs and link events are attributed correctly to your acquisition campaigns on iOS and Android.
Almedia Link uses the AppsFlyer UID to attribute installs and link events to your acquisition campaigns. Retrieve it at runtime and pass it to the SDK during initialization — your engineering team handles the code, but you need to know what to request and why it matters for your revenue share.
## What to pass
Pass the `AppsFlyerId` field in `AlmediaLinkConfig` when calling `AlmediaLinkSDK.Initialize`. This is handled by your engineering team — see the Integration Guide for the full Initialize snippet.
The field name to share with your engineer is `AppsFlyerId`. It sits inside the `AlmediaLinkConfig` object passed to the SDK at startup. No other AppsFlyer-specific configuration is required on your end.
## How to retrieve the AppsFlyer UID
The AppsFlyer SDK exposes a UID that your engineer retrieves at runtime — consult your AppsFlyer SDK documentation for the exact method. Your engineer calls it before calling Initialize and assigns the result to the `AppsFlyerId` field. The UID is a string unique to each install — it is distinct from an advertising identifier and does not require ATT consent to read.
Share the field name `AppsFlyerId` with your engineer so they know exactly where to slot the value.
## What Almedia does with it
Almedia uses the AppsFlyer UID to match the linking event back to the original install campaign. When a player links their Freecash account, that event is tied to the install AppsFlyer already recorded. This ensures CPA revenue is attributed correctly to your campaigns and your revenue share reflects your actual traffic — not an estimate.
Do not pass a hardcoded or placeholder value. Attribution will fail silently if the UID is wrong, resulting in missed revenue. Always retrieve the value at runtime from the AppsFlyer SDK.
Review everything you need in place before going live.
The complete technical walkthrough for your engineering team.
# Configure Singular Attribution for Almedia Link SDK
Source: https://almedia-c3396e23.mintlify.app/publisher/mmp/singular
Pass the right device identifier to the Almedia Link SDK to attribute installs and link events correctly to your Singular campaigns.
If you use Singular as your MMP, pass a device identifier that Singular tracks to ensure Almedia Link events are attributed back to your campaigns correctly. The setup is slightly different from Adjust and AppsFlyer — read this page carefully before briefing your engineer.
## What to pass
Singular-tracked installs are best attributed using GAID (Android) or IDFA (iOS) — the same identifiers Singular uses for attribution. Pass these via the `Gaid` and `Idfa` fields in `AlmediaLinkConfig`. Confirm the right field with your Almedia integration manager before your engineer starts implementation.
Share the relevant field names — `Gaid` for Android or `Idfa` for iOS — with your engineer depending on which platform your Singular setup covers.
## How to retrieve the identifier
Use the Singular SDK or your existing analytics layer to read GAID (Google Advertising ID) on Android or IDFA (Identifier for Advertisers) on iOS at runtime. Both values are strings. IDFA requires ATT consent on iOS 14.5 and later — if your game does not request ATT, use GAID for Android only and confirm the fallback approach with your Almedia integration manager for iOS.
Share the correct field name with your engineer once you've confirmed the identifier type with Almedia.
## What Almedia does with it
Almedia uses the identifier to match the linking event back to the original install campaign that Singular recorded. When a player links their Freecash account, the event is tied to that install. This ensures CPA revenue is attributed correctly to your Singular campaigns and your revenue share reflects your actual traffic — not an approximation.
Do not pass a hardcoded or placeholder value. Attribution will fail silently if the identifier is wrong, resulting in missed revenue. Always retrieve the value at runtime and confirm the correct field with your Almedia integration manager.
Review everything you need in place before going live.
The complete technical walkthrough for your engineering team.
# Set Up Almedia Link: Publisher Prerequisites Checklist
Source: https://almedia-c3396e23.mintlify.app/publisher/prerequisites
Everything a publisher needs before going live with Almedia Link — integration keys, MMP configuration, and Unity version requirements.
Before your engineering team starts the SDK integration, make sure the following items are in place. Work through them top to bottom and you'll hand off to engineering with zero blockers.
### Sign the commercial agreement
Sign the integration agreement with Almedia. Your integration manager provides the contract and the revenue-share terms. Nothing else on this list moves forward until this is done.
### Get your integration keys
Your Almedia integration manager issues a separate key for iOS and Android. Keep them in a secure secrets manager, not in public source control. Leaked keys can be exploited to fraudulently attribute link events against your account.
### Confirm the Unity version
The SDK requires Unity 2022.3 LTS or later. Confirm your project is on a supported version before your engineer picks up the work. Platform minimums are iOS 16.0 and Android API 27. Projects below these targets are not supported.
### Configure your MMP
If you use an MMP (Adjust, AppsFlyer, or Singular), configure it to pass the right device identifier to the SDK. Accurate attribution directly affects your revenue share, and skipping this step means missed CPA credits. See the sub-pages below for your specific MMP.
### Align on the in-game reward
Decide what in-game reward you'll offer players who link: coins, lives, premium currency, or another asset. This reward is displayed in the link pop-up and is one of the strongest conversion drivers. Share the final copy and reward value with your integration manager before launch.
### Review best practices
Read the best practices guide before the integration goes live. Pop-up timing and social proof materially affect link rate. Publishers who follow the guide consistently outperform those who don't.
Your integration manager will guide you through each step. If you don't have one yet, reach out to Almedia through the contact on your agreement.
Configure Adjust device ID passing for accurate attribution.
Configure AppsFlyer UID passing for accurate attribution.
Configure Singular identifier passing for accurate attribution.
# Almedia Link SDK API Reference for Unity Engineers
Source: https://almedia-c3396e23.mintlify.app/technical/api-reference
Complete API reference for the Almedia Link Unity SDK covering all methods, events, models, and editor testing hooks, synced from GitHub.
The API Reference documents every public type in the Almedia Link Unity SDK: the `AlmediaLinkSDK` static facade, `AlmediaLinkConfig`, `AlmediaLinkSettings`, all model types, UI controllers, prefabs, and editor testing hooks. The content syncs from the GitHub repository.
This page syncs from [github.com/almedia-tm/almedia-link-sdk](https://github.com/almedia-tm/almedia-link-sdk) — specifically `Documentation~/api-reference.md`. Until the sync is connected, read the reference directly on GitHub.
## Public surface summary
Static facade: Initialize, StartLinking, ShowRewardHub, ShowOffer, Engage, FetchNotifications, polling controls, events.
Runtime config: integration keys, advertising IDs, polling interval.
AlmediaStatus, AlmediaError, AlmediaNotification, PlacementType, AlmediaScreen, InAppScreenResult.
AlmediaLinkEditorMock for driving non-happy paths in play-mode tests.
**Coding agent tip:** the SDK repo README plus an integration key is sufficient context for a coding agent to produce a correct integration. Point the agent at [https://github.com/almedia-tm/almedia-link-sdk](https://github.com/almedia-tm/almedia-link-sdk) and provide the key.
# Almedia Link SDK — Complete Unity Integration Guide
Source: https://almedia-c3396e23.mintlify.app/technical/integration-guide
Step-by-step guide to integrating the Almedia Link Unity SDK: install the package, set integration keys, initialize the SDK, and handle reward events.
The Integration Guide walks engineers through every step of embedding Almedia Link in a Unity game: installing the package, configuring integration keys, initializing the SDK, customizing the UI, handling the status lifecycle, setting up reward notifications, and troubleshooting. The content syncs from the GitHub repository.
This page syncs from [github.com/almedia-tm/almedia-link-sdk](https://github.com/almedia-tm/almedia-link-sdk) — specifically `Documentation~/integration-guide.md`. Until the sync is connected, read the guide directly on GitHub.
## Topics covered
* Overview
* Threading
* Requirements
* Integration keys
* Installation
* SDK configuration
* UI customization
* Initialization
* Status lifecycle
* Link Button
* Linking flow
* Reward Hub
* Offers
* Pausing the game
* Reward notifications
* iOS ATT
* Android Gradle dependencies
* Logging
* Error handling
* Crash symbolication
* Editor testing
* Troubleshooting
View the full integration guide in the source repository.
Browse every public type, method, and event in the SDK.
# Almedia Link SDK — README and Quick-Start Overview
Source: https://almedia-c3396e23.mintlify.app/technical/readme
The Almedia Link SDK README on GitHub covers installation, platform requirements, quick-start code, UI customization options, and crash symbolication.
The Almedia Link SDK README is the canonical starting point for engineers. It covers installation, platform support, a quick-start snippet, customization levels, editor testing, and crash symbolication. The content on this page syncs automatically from the GitHub repository.
This page syncs from [github.com/almedia-tm/almedia-link-sdk](https://github.com/almedia-tm/almedia-link-sdk). Content will appear here once the GitHub sync is connected. Until then, read the README directly on GitHub.
Read the full README on GitHub.
Step-by-step guide to embedding Almedia Link in your Unity game.