Deep Linking for Mobile Games (2026): Multiplayer Invites, Level Sharing & Re-Engagement

Deep links for mobile games, they power referral reward flows, level sharing, multiplayer invites, and re-engagement campaigns, and with deferred deep linking, the context survives the install.

Narendra Thadani

• 5 min read
Deep Linking for Mobile Games (2026): Multiplayer Invites, Level Sharing & Re-Engagement
Deep Links for Gaming Apps, with Chottulink Unity SDK

Imagine your friend sends you a link to a game, challenging you to beat a specific level and win bonus coins. You tap it. The game opens. But on the home screen. No level. No coins. No context.

Your friend swears they sent the right link. Both of you are confused. The excitement is gone. And for the gaming company, that was a warm, referred user. Gone.

This is the problem deep links solve. For games, where every session is built on momentum and context, a broken link does not just frustrate players. It breaks trust.

This post covers four concrete deep linking use cases for mobile games, with real implementation examples using the ChottuLink Unity SDK.

The short answer: Deep linking for mobile games routes players to specific in-game destinations (a level, lobby, or reward screen) instead of the home screen. With deferred deep linking, that context survives an app install, so referral rewards, multiplayer invites, and challenge links work even for players who do not have the game yet.

What Is Deep Linking in the Gaming Context?

A deep link routes a player to a specific in-app destination, not just the app's home screen. In gaming, that might be:

  • A reward claim screen after a referral
  • A specific level or puzzle shared by a friend
  • A multiplayer lobby for a pending invite
  • A limited-time event triggered by a push notification

Deferred deep linking extends this to new installs. The player clicks a link, does not have the game installed, goes through the App Store or Play Store, installs the game, and still lands on the intended destination. The link context survives the entire install flow.

Games like kryss.app and yesgnome.com use ChottuLink's Unity SDK to power these flows on both iOS and Android from a single C# codebase.

Use Case 1: Referral and Reward Campaigns for Mobile Games

The "earn 500 coins when a friend joins" mechanic is a proven growth loop. But it only works if the referred user actually lands on the reward screen.

Without deferred deep linking, the flow breaks the moment the user does not have the game installed. They hit the App Store, install, open the game, and see a generic home screen. The reward is gone. So is any reason to keep playing.

With ChottuLink, the invite link carries the referrer ID and reward code through the install. When the new player opens the game for the first time, the SDK fires with isDeferred=true and delivers the original link URL. Your code applies the reward automatically:

ChottuLink.OnLinkReceivedWithMeta += (resolved) => {
    if (resolved == null || string.IsNullOrEmpty(resolved.link)) return;

    var uri = new System.Uri(resolved.link);
    if (uri.AbsolutePath.StartsWith("/reward/")) {
        string rewardCode = uri.Query.TrimStart('?');
        if (resolved.isDeferred == true) {
            GameManager.Instance.ApplyReward(rewardCode);
        }
    }
};

No copy-pasting codes. No manual entry. The reward is applied in context, on first open.

Use Case 2: Level Sharing and Custom Challenges in Gaming Apps

Social sharing is one of the most effective growth mechanics in mobile gaming. But only when the shared link actually delivers the shared content.

"Beat my score on Level 47" is compelling. "Beat my score on Level 47 (open the game, go to the Challenges tab, scroll down...)" is not.

A ChottuLink deep link encodes the specific challenge or level ID in the path. When a friend clicks it, the game opens directly to that game state. If they do not have the game installed, they go through the store and still land there automatically via deferred deep linking.

void HandleDeepLink(string url) {
    System.Uri uri = new System.Uri(url);
    string path = uri.AbsolutePath;

    if (path.StartsWith("/challenge/")) {
        string challengeId = path.Split('/')[2];
        PlayerPrefs.SetString("pending_challenge_id", challengeId);
        SceneManager.LoadScene("Challenge");
    }
}

This is the pattern that makes challenge links shareable across Discord, iMessage, and social feeds. It turns social sharing into actual installs.

Use Case 3: Re-Engagement Campaigns for Gaming Apps via Push, SMS, and Email

Players go dormant. The question is what brings them back.

A generic push notification ("You have not played in a while!") performs poorly. A contextual one, "Your unfinished level 23 is waiting. The reward expires in 2 hours," does much better. But the notification is only half of it. The link still needs to take the player directly to level 23, not the home screen.

ChottuLink links in push notifications, SMS, and email campaigns work as standard deep links when the app is installed. Your notification payload includes the ChottuLink URL, and the SDK routes the player on open:

if (path.StartsWith("/level/")) {
    string levelId = path.Split('/')[2];
    PlayerPrefs.SetString("resume_level_id", levelId);
    SceneManager.LoadScene("GameLevel");
}

The same link also handles players who deleted the game. It routes them through the App Store first, then delivers the context on reinstall.

Use Case 4: Multiplayer Invites

"Join my squad" is one of the most common organic growth triggers in multiplayer games. It is also one of the harder ones to build. Squad IDs, session states, cross-platform routing -- most studios skip it or wire it up with a manual code flow that adds unnecessary friction.

With ChottuLink, a multiplayer invite link embeds the squad ID, inviter identity, and any mission context in the URL path. When the recipient clicks it:

  • Game installed: opens directly to the lobby
  • Not installed: routes through the store, and on first open delivers the invite context
if (path.StartsWith("/invite/")) {
    string inviteCode = path.Split('/')[2];
    PlayerPrefs.SetString("pending_invite_code", inviteCode);

    if (resolved.isDeferred == true) {
        ReferralManager.CreditReferral(inviteCode);
    }

    SceneManager.LoadScene("Lobby");
}

No room codes. No asking your friend what the code was. One tap, right lobby.

Setting Up Deep Linking in Your Unity Game

The ChottuLink Unity SDK ships as a .unitypackage for both iOS and Android. Integration involves:

  1. Import ChottuLink.unitypackage via Assets > Import Package > Custom Package
  2. Configure your iOS bundle ID and Android package name in the ChottuLink dashboard
  3. Add Associated Domains (applinks:yourgame.chottu.link) in Xcode for iOS
  4. Add an intent filter to AndroidManifest.xml for Android App Links
  5. Initialize and subscribe to OnLinkReceivedWithMeta in a persistent MonoBehaviour

Full setup instructions — including AndroidManifest configuration, Associated Domains for iOS, and deferred deep link testing steps — are in the ChottuLink Unity deep linking guide.

Platform requirements: iOS 15.6+, Android API 23+, Unity LTS (2022 or 2023), Xcode 16.2+.

Firebase Dynamic Links shut down on August 25, 2025. If your Unity game was still using Firebase Dynamic Links, your deep links have been silently failing since then.

ChottuLink is a drop-in replacement with the same core capabilities: deferred deep linking, custom domain support, iOS Universal Links, Android App Links, and a dashboard with real-time analytics. The Unity SDK is a .unitypackage with a clean C# API. No rewiring of your existing routing logic required.

Frequently Asked Questions

Deep links make referral and reward campaigns effective. When a player shares an invite link, the recipient is routed to the App Store or Play Store if the game is not installed, downloads it, and lands directly on the reward claim screen, not the home screen. The referral context survives the install. This is called deferred deep linking.

Yes. A deep link can encode a specific game state: a puzzle, challenge ID, or leaderboard entry. When a friend clicks the link, they land on that exact state, even if they had to install the game first. The link context is preserved through the install flow.

Push notifications, SMS, and email campaigns that contain deep links take a lapsed player directly to an unfinished level, an expiring in-game reward, or a limited-time event, rather than the app home screen. Contextual re-engagement performs much better than a generic "come back" prompt.

A multiplayer invite link embeds the squad ID, mission context, and inviter identity. When the recipient clicks it, the ChottuLink Unity SDK fires OnLinkReceivedWithMeta with the full URL and isDeferred=true if they had to install first. Your C# handler reads the invite code and routes the new player directly into the correct lobby. No room codes, no manual searching.

Yes. ChottuLink's Unity SDK (.unitypackage) exposes OnLinkReceivedWithMeta which provides ResolvedLink.isDeferred. When a new player installs after clicking an invite or challenge link, the SDK delivers the original link context on first open, so you can credit referrals, pre-fill invite codes, and route new players to the right scene automatically.