Quickstart

{
  "name": "My App",
  "ios_bundle_id": "com.example.myapp",
  "ios_team_id": "ABCDE12345",
  "ios_app_store_url": "https://apps.apple.com/app/id123456789"
}

{
  "name": "My App",
  "android_package_name": "com.example.myapp",
  "android_sha256_fingerprints": ["AA:BB:CC:..."],
  "android_play_store_url": "https://play.google.com/store/apps/details?id=com.example.myapp"
}

{
  "name": "My App",
  "ios_bundle_id": "com.example.myapp",
  "ios_team_id": "ABCDE12345",
  "android_package_name": "com.example.myapp",
  "android_sha256_fingerprints": ["AA:BB:CC:..."]
}

Add WarpLink via Swift Package Manager:

https://github.com/WarpLinkApp/warplink-ios-sdk.git

Configure in your AppDelegate. One onLink callback receives taps and deferred installs:

import WarpLink

func application(
  _ application: UIApplication,
  didFinishLaunchingWithOptions options: [UIApplication.LaunchOptionsKey: Any]?
) -> Bool {
  WarpLink.configure(
    apiKey: "wl_live_yoursdkkeyhere000000000000000000",
    options: WarpLinkOptions(onLink: { result in
      if case .success(let link) = result, let link {
        navigate(to: link)
      }
    })
  )
  return true
}

Then forward the tapped URL to the SDK (there is no swizzling):

func application(
  _ application: UIApplication,
  continue userActivity: NSUserActivity,
  restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
) -> Bool {
  WarpLink.continue(userActivity)
}

Scene-based apps forward from their scene delegate instead, and setting your delegate class to the drop-in WarpLinkAppDelegate or WarpLinkSceneDelegate does it for you. See the iOS SDK guide.

Add to your build.gradle.kts:

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

Initialize in your Application class. Cold start and the deferred check are wired automatically:

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

Install the package:

npm install @warplink/react-native

Configure in your app entry. One onLink callback handles cold start, warm start, and deferred installs:

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

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

On iOS, forward the tapped URL from your AppDelegate so taps reach the SDK. Add the WarpLink call to the delegate method you already have and keep returning your existing linking result, so React Navigation and Expo Linking still receive the URL:

// 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)
  }
  return RCTLinkingManager.application(
    application, continue: userActivity, restorationHandler: restorationHandler)
}

Android needs no host code. The React Native SDK guide covers the Objective-C form, custom URL schemes, and Expo prebuild. If your app has a SceneDelegate (Info.plist declares UIApplicationSceneManifest), the iOS SceneDelegate hook is also required: iOS stops calling the AppDelegate method above once a scene exists.

Add the package:

flutter pub add warplink_flutter

Configure once from your root widget's initState. One onLink callback handles cold start, warm start, and deferred installs:

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

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

navigateTo waits for your navigator before it pushes a route. The Flutter SDK guide has the full root widget and the navigatorKey setup.

No AppDelegate, SceneDelegate, or MainActivity code is needed. On Android, set minSdk = 26 in android/app/build.gradle.kts and keep the launchMode your Flutter template sets. The Flutter SDK guide covers both platforms, including Flutter's own link handling.