Branch Migration

Remove Branch:

1. Remove the BranchSDK package (CocoaPods pod 'BranchSDK', SPM https://github.com/BranchMetrics/ios-branch-sdk-spm, or Carthage github "BranchMetrics/ios-branch-deep-linking")
2. Remove the Branch.getInstance() / initSession(launchOptions:) call
3. Remove the branch_key and branch_universal_link_domains keys from Info.plist
4. Remove the applinks:subdomain.app.link Associated Domains entries (including the -alternate and .test variants)

Add WarpLink:

// Package.swift
dependencies: [
    .package(url: "https://github.com/WarpLinkApp/warplink-ios-sdk", from: "1.1.0")
]

Remove Branch:

// Remove from build.gradle.kts
// implementation("io.branch.sdk.android:library:<version>")

Also remove the io.branch.sdk.BranchKey, io.branch.sdk.BranchKey.test, and io.branch.sdk.TestMode manifest meta-data entries, and the custom URI scheme and HTTPS App Links intent filters pointed at your app.link domains.

Add WarpLink:

dependencies {
    implementation("app.warplink:sdk:1.1.0")
}

Remove Branch:

npm uninstall react-native-branch
cd ios && pod install

Add WarpLink:

npm install @warplink/react-native

The iOS SDK is distributed through Swift Package Manager and needs dynamic linkage, so add this to ios/Podfile inside your app target before installing pods:

# ios/Podfile, inside your app target
use_frameworks! :linkage => :dynamic

cd ios && pod install

Before (Branch):

Branch.getInstance().initSession(launchOptions: launchOptions)

After (WarpLink):

import WarpLink

WarpLink.configure(
    apiKey: "wl_live_yoursdkkeyhere000000000000000000",
    options: WarpLinkOptions(onLink: { result in
        if case .success(let link) = result, let link {
            navigate(to: link) // taps AND deferred installs (check link.isDeferred)
        }
    })
)

Before (Branch):

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        Branch.getAutoInstance(this)
    }
}

After (WarpLink):

import app.warplink.WarpLink
import app.warplink.WarpLinkOptions

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        WarpLink.configure(
            context = this,
            apiKey = "wl_live_yoursdkkeyhere000000000000000000",
            options = WarpLinkOptions(onLink = { result ->
                result.onSuccess { link -> navigateTo(link) }
            })
        )
    }
}

Before (Branch):

import branch from 'react-native-branch';

branch.subscribe(({ error, params }) => {
    if (error) return;
    // handle params
});

After (WarpLink):

import { WarpLink } from '@warplink/react-native';

WarpLink.configure({
    apiKey: 'wl_live_yoursdkkeyhere000000000000000000',
    onLink: ({ deepLink }) => deepLink && navigateTo(deepLink.destination),
});

In Signing & Capabilities > Associated Domains:

- applinks:yourapp.app.link
+ applinks:aplnk.to

Remove every applinks: entry for your app.link (and legacy bnc.lt) subdomain, including the -alternate and .test variants Branch adds automatically.

In AndroidManifest.xml, update the intent filter host and remove Branch's custom URI scheme filter:

  <data
      android:scheme="https"
-     android:host="yourapp.app.link" />
+     android:host="aplnk.to" />

Remove the android:autoVerify="true" intent filters for both your live and test app.link domains.

Delete the Branch calls inside application(_:open:options:) and application(_:continue:restorationHandler:) (and the SceneDelegate equivalents, scene(_:continue:) and scene(_:openURLContexts:), if your app uses scenes). Forward the same URL or activity to WarpLink instead:

func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
    WarpLink.open(url) // was Branch's handler
    return true
}

func application(
    _ application: UIApplication,
    continue userActivity: NSUserActivity,
    restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
) -> Bool {
    WarpLink.continue(userActivity) // was Branch's handler
    return true
}

Resolved links arrive in your onLink callback. Or set your delegate class to the drop-in WarpLinkAppDelegate / WarpLinkSceneDelegate and skip writing these methods yourself.

Delete the Branch.sessionBuilder(this).withCallback { ... }.withData(intent.data).init() call from your Activity's onStart(). Cold start is automatic once onLink is set at configure(). For warm start, forward new intents and keep android:launchMode="singleTask" on the Activity:

override fun onNewIntent(intent: Intent) {
    super.onNewIntent(intent)
    WarpLink.onNewIntent(intent) // was Branch's onStart() session
}

Resolved links arrive in your onLink callback.

Delete the branch.subscribe(...) callback. WarpLink.configure()'s onLink callback covers cold start, warm start, and deferred installs in one callback, the same way subscribe did.

On iOS you are removing the Branch line from a delegate method that already exists and already forwards to your linking library. Swap it for the WarpLink call and leave the rest of the method alone. Do not let handleIncomingURL decide the return value: it returns nothing, and replacing the forwarded result breaks React Navigation, Expo Linking, and OAuth callbacks.

// ios/YourApp/AppDelegate.swift
import React
import warplink_react_native

func application(
  _ application: UIApplication,
  continue userActivity: NSUserActivity,
  restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
) -> Bool {
  if userActivity.activityType == NSUserActivityTypeBrowsingWeb,
     let url = userActivity.webpageURL {
    WarpLinkModule.handleIncomingURL(url)   // was Branch's handler
  }
  return RCTLinkingManager.application(
    application, continue: userActivity, restorationHandler: restorationHandler)
}

Android needs no host code, given android:launchMode="singleTask". See the React Native SDK guide for the Objective-C form and Expo prebuild, and the iOS SceneDelegate hook if your app has a SceneDelegate.

Branch's deferred deep linking on iOS 15+ with Private Relay enabled relies on NativeLink (the $ios_nativelink link parameter), delivered through the same session-init callback as a direct tap. WarpLink runs its deferred check automatically from configure() and delivers the match to the same onLink callback, flagged with isDeferred:

options: WarpLinkOptions(onLink: { result in
    guard case .success(let deepLink) = result, let deepLink else { return }
    if deepLink.isDeferred {
        print("Match confidence: \(deepLink.matchConfidence ?? 0)")
    }
    navigate(to: deepLink)
})

Branch delivers a deferred match through the same sessionBuilder().init() callback used for a direct link open. WarpLink runs its deferred check automatically from configure() and delivers the match to the same onLink callback, flagged with isDeferred:

options = WarpLinkOptions(onLink = { result ->
    result.onSuccess { deepLink ->
        if (deepLink.isDeferred) {
            Log.d("MyApp", "Match confidence: ${deepLink.matchConfidence}")
        }
        navigateTo(deepLink)
    }
})

Branch's subscribe callback also surfaces deferred params on cold start: the result is cached natively and delivered if subscribe is called within a TTL (default 5000ms, configurable via branch.initSessionTtl). WarpLink runs its deferred check automatically from configure() and delivers the match to the same onLink callback, flagged with isDeferred, with no TTL to configure:

WarpLink.configure({
    apiKey: 'wl_live_yoursdkkeyhere000000000000000000',
    onLink: ({ deepLink }) => {
        if (!deepLink) return;
        if (deepLink.isDeferred) console.log('Match confidence:', deepLink.matchConfidence);
        navigateTo(deepLink.destination);
    },
});