Skip to documentation

Deep Links

Kixo Deep Links send each person to the best available destination. If the app is installed, the same branded HTTPS link opens the right screen in the app. Otherwise it can open your website, App Store, or Google Play fallback. The operating system handles a verified app opening; when the link reaches the browser, Kixo applies the fallback saved for that link.

Start in Kixo

Open Project Settings → Deep links, create an address, and copy the setup shown for that address. The host in the dashboard is the source of truth for every snippet below.

How a link opens

Person's deviceResult
App installed and app-link setup is validThe app opens directly at the link destination.
App not installedKixo uses the website or store fallback selected for the link.
Desktop browserThe website fallback opens.
App setup incompleteThe safe fallback opens instead of showing a broken app prompt.

Use the exact branded host

A Kixo link host belongs to one project and looks like yourbrand.kixo.cc. Development projects may use a different Kixo-managed ending. Always copy the complete host from the dashboard.

Wildcards do not work

Configure yourbrand.kixo.cc, not *.kixo.cc and not kixo.cc. Android and iOS verify the exact host that the person opens.

Website and QR handoff

The Web SDK recognizes a Kixo link landing automatically. Use getLinkData() only when your website needs the resolved campaign context or custom parameters in its own router.

js
const link = Kixo.getLinkData();

if (link?.params.product_id) {
  // URL values are user-controlled. Allowlist them before routing.
  router.openProduct(link.params.product_id);
}

Offer “Open in app” on mobile web

Pass the complete public link URL returned by Kixo. The banner is shown only on mobile web and lets the Kixo link choose the installed app, store, or website destination.

js
Kixo.showSmartBanner({
  linkId: 'YOUR_KIXO_LINK_ID',
  linkUrl: 'https://YOUR_EXACT_KIXO_HOST/link/YOUR_LINK_SLUG',
  title: 'Continue in the app',
});

Continue a desktop session from a QR code

For a QR shown inside your website, ask Kixo to create a handoff for an existing link instead of constructing a URL yourself. Kixo uses the app and website destinations saved for that link.

js
const handoff = await Kixo.createQrHandoff({
  linkId: 'YOUR_KIXO_LINK_ID',
  params: {
    product_id: '42',
  },
});

qrCode.render(handoff.url);

Use the values returned by Kixo

Pass the link ID from Kixo and render the returned URL unchanged. Optional params add context for your allowlisted app or website route; they do not replace the link's destination. Do not pass a user ID or device ID.

Android App Links

Before editing code, save the Android package name and every SHA-256 app signing fingerprint in Apps & setup. If Google Play signs the release, add the Play App Signing fingerprint as well as any fingerprint used by direct or internal builds.

1. Add the host to the manifest

Put this intent filter on the activity that owns app navigation. Replace only the host placeholder.

xml
<activity
    android:name=".MainActivity"
    android:exported="true">
    <intent-filter android:autoVerify="true">
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data
            android:scheme="https"
            android:host="YOUR_EXACT_KIXO_HOST"
            android:pathPrefix="/link/" />
    </intent-filter>
</activity>

2. Forward warm opens

The Kixo SDK reads a cold-start App Link. When Android reuses an existing activity, forward its new intent so the warm open follows the same attribution and routing path.

kotlin
import android.content.Intent
import io.kixo.sdk.Kixo

override fun onNewIntent(intent: Intent) {
    super.onNewIntent(intent)
    setIntent(intent)
    intent.dataString?.let { url ->
        Kixo.handleDeepLink(url, source = "applink")
    }
}

3. Verify Android

Reinstall the app after changing the manifest, then ask Android to verify the host and inspect the result.

bash
adb shell pm verify-app-links --re-verify YOUR_ANDROID_PACKAGE
adb shell pm get-app-links YOUR_ANDROID_PACKAGE

# The exact host should be "verified".
adb shell am start -W \
  -a android.intent.action.VIEW \
  -d "https://YOUR_EXACT_KIXO_HOST/link/YOUR_LINK_SLUG"

Tip

A browser chooser usually means the exact host, package name, or signing fingerprint does not match. Check those three values before changing app navigation code.

iOS Universal Links

Save the app's bundle ID and Apple team ID in Apps & setup. In Xcode, enable the Associated Domains capability on the same app target and signing configuration used by the installed build.

1. Add the associated domain

applinks:YOUR_EXACT_KIXO_HOST

2. Forward cold and warm links

Choose the lifecycle used by the app. Both examples deliver the resolved destination to your own router; Kixo does not replace app navigation.

import Kixo

WindowGroup {
    ContentView()
        .onKixoDeepLink { link in
            guard link.phase == .resolved else { return }
            router.open(link.targetPath ?? link.path)
        }
}

3. Verify iOS

  1. Delete the app from the device, then install the signed build.
  2. Open a real Kixo link from Notes, Messages, or Safari. Do not paste it into the Safari address bar for the only test.
  3. Confirm a cold tap launches the app at the expected screen.
  4. Leave the app running, tap the link again, and confirm the warm open.
  5. Confirm the link open appears in Kixo.

Keep routing inside your app

A Kixo link can carry a destination such as /products/42. Map known paths to your own screens and keep the app's existing access checks. Do not turn the resolved value into a general-purpose URL opener.

Kixo.setDeferredDeepLinkListener { link ->
    if (link?.phase != KixoDeepLinkPhase.RESOLVED) return@setDeferredDeepLinkListener
    when {
        link.targetUrl?.startsWith("/products/") == true ->
            router.openProduct(link.targetUrl.substringAfterLast("/"))
        link.targetUrl == "/account" ->
            router.openAccount()
    }
}

Give this to a coding assistant

Replace the five placeholders with values from Project Settings → Apps & setup and Deep links, then paste the complete brief into Codex, Claude Code, Cursor, Windsurf, or another coding assistant.

text
Add Kixo Deep Links to this app.

Project values:
- Kixo branded host: YOUR_EXACT_KIXO_HOST
- Android package name: YOUR_ANDROID_PACKAGE
- Android SHA-256 signing fingerprints: YOUR_ANDROID_FINGERPRINTS
- iOS bundle ID: YOUR_IOS_BUNDLE_ID
- Apple team ID: YOUR_APPLE_TEAM_ID

Requirements:
1. Use the exact branded host above. Do not replace it with kixo.cc, dixo.dev, a wildcard, or the website domain.
2. Keep the app's existing navigation. Kixo resolves and measures the link; the app decides which screen to show.
3. Android:
   - add an android:autoVerify App Links intent filter for https://YOUR_EXACT_KIXO_HOST/link/
   - keep the package name and every release signing fingerprint in Kixo Apps & setup
   - forward warm Activity.onNewIntent URLs to Kixo.handleDeepLink(url, source = "applink")
4. iOS:
   - add applinks:YOUR_EXACT_KIXO_HOST to the app target's Associated Domains entitlement
   - keep the bundle ID and Apple team ID in Kixo Apps & setup
   - for SwiftUI, attach .onKixoDeepLink to the root view
   - for UIKit scenes, forward cold connectionOptions and warm NSUserActivity callbacks to Kixo
5. Route only known in-app paths. Do not blindly open an arbitrary URL returned by a link.
6. Test a cold open and a warm open on a physical device or emulator. Confirm the app opens directly and the link open appears in Kixo.

Return:
- the files changed
- the exact host configured in each platform
- cold-open and warm-open test results
- anything still requiring a dashboard or signing-account change

What the assistant must not guess

The branded host, package name, signing fingerprints, bundle ID, and Apple team ID come from your app and Kixo project. An assistant can wire the code, but it should stop and report a missing value instead of inventing one.

Release checklist

  • The exact Kixo host is present in Android and iOS setup.
  • Android reports the host as verified for the release package.
  • The release signing fingerprints are saved in Kixo.
  • The iOS entitlement is present in the signed app build.
  • Cold and warm opens reach the expected screen.
  • The website or store fallback works without the app installed.
  • The link open appears in Kixo analytics.

Related guides