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.1")
]

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.1")
}

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

Remove Branch:

flutter pub remove flutter_branch_sdk

Add WarpLink:

flutter pub add warplink_flutter

The iOS SDK is distributed through Swift Package Manager, so there is no Podfile change. If your Flutter version does not use Swift Package Manager by default, run flutter config --enable-swift-package-manager once.

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),
});

Before (Branch):

import 'package:flutter_branch_sdk/flutter_branch_sdk.dart';

await FlutterBranchSdk.init();
FlutterBranchSdk.listSession().listen((data) {
  // handle data
});

After (WarpLink):

import 'dart:async';

import 'package:flutter/material.dart';
import 'package:warplink_flutter/warplink_flutter.dart';

class _AppState extends State<App> {
  @override
  void initState() {
    super.initState();
    unawaited(
      WarpLink.configure(
        apiKey: 'wl_live_yoursdkkeyhere000000000000000000',
        onLink: (event) {
          if (event is! LinkEvent) return;
          final deepLink = event.deepLink;
          navigateTo(deepLink.deepLinkUrl ?? deepLink.destination);
        },
      ),
    );
  }
}

Call configure() once from your root widget's initState, without awaiting it. deepLinkUrl is the app route; destination is the web URL and serves only as the fallback. A link that launches the app can arrive before the first frame, so make navigateTo wait for the navigator, as in With a Navigator Key.

In Signing & Capabilities > Associated Domains:

- applinks:yourapp.app.link
+ applinks:yourapp.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="yourapp.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.

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

Switch off Flutter's own link handling so it does not also route the link as a page. In ios/Runner/Info.plist:

<key>FlutterDeepLinkingEnabled</key>
<false/>

In android/app/src/main/AndroidManifest.xml, inside your main <activity>:

<meta-data android:name="flutter_deeplinking_enabled" android:value="false" />

There is no delegate or Activity code to port. The plugin registers with Flutter's iOS and Android lifecycles, so any forwarding you added to AppDelegate or MainActivity for Branch can go. Set minSdk = 26 in android/app/build.gradle.kts, and see the Flutter SDK guide for the Associated Domains capability and the intent filter.

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);
    },
});

Branch delivers deferred params through the same listSession() stream. WarpLink runs its deferred check automatically from configure() and delivers the match to the same onLink callback, flagged with isDeferred:

import 'dart:async';

import 'package:flutter/material.dart';
import 'package:warplink_flutter/warplink_flutter.dart';

class _AppState extends State<App> {
  @override
  void initState() {
    super.initState();
    unawaited(
      WarpLink.configure(
        apiKey: 'wl_live_yoursdkkeyhere000000000000000000',
        onLink: (event) {
          if (event is! LinkEvent) return;
          final deepLink = event.deepLink;
          if (deepLink.isDeferred) debugPrint('Match confidence: ${deepLink.matchConfidence}');
          navigateTo(deepLink.deepLinkUrl ?? deepLink.destination);
        },
      ),
    );
  }
}