SDKs
Open source SDKs for iOS, Android, React Native, and Flutter
WarpLink ships four open source SDKs, for iOS, Android, React Native, and Flutter, each MIT licensed with zero third-party dependencies and a single configure() call that wires up deep links, deferred deep links, and install attribution. Deep linking, install attribution, and real-time analytics all come from that one integration, on every platform you ship, instead of from separate SDKs you would have to keep in step.
What is a deep linking SDK?
A deep linking SDK is the library inside your mobile app that receives a tapped link and hands your code the screen it named. WarpLink ships open source SDKs for iOS, Android, React Native, and Flutter, and one configure() call wires up cold start, warm start, the deferred deep link check, and install attribution.
How it works
Create an SDK key. In the dashboard, open Keys, then SDK keys. An SDK key is pre-scoped for link resolution and install attribution, and it can be tied to one app.
Add the package. Use Swift Package Manager on iOS, Maven Central on Android, npm on React Native, and pub.dev on Flutter. The packages have zero third-party dependencies.
Call configure() once. Pass your SDK key and an onLink callback, as early in the app lifecycle as you can. That one call wires up everything else.
Declare your link domains. Add the Associated Domains entitlement on iOS and the autoVerify intent filter on Android, so each system opens your app for the link domain.
Handle each link in onLink. The callback receives every resolved link, from a tap or from a deferred install match. Check isDeferred to tell them apart, then route to the screen. The attribution result lands on the same first launch.
Opt out of any piece you want to drive. Automatic deep link handling and the deferred check each turn off with a single flag, and you call the manual methods instead.
Key facts
- The iOS, Android, React Native, and Flutter SDKs are all at version 1.1.1, open source under the MIT license.
- Minimum versions: iOS 15, Android API 26, React Native 0.75, and Flutter 3.38.
- All four have zero third-party dependencies, and the source is public under the WarpLinkApp organization on GitHub.
- The SDKs read no advertising identifier and ask for no permission.
- React Native works with Expo through a development build, not Expo Go.
- Plans start at Free ($0, 10K clicks a month) and run through Starter ($19), Growth ($49), and Scale ($99) to Unlimited ($149, no click ceiling).
One SDK per platform
iOS
v1.1.1Android
v1.1.1React Native
v1.1.1Flutter
v1.1.1
How the deep linking SDKs work
Install
Add the SDK the way you already add dependencies: Swift Package Manager on iOS, Maven Central on Android, npm on React Native, and pub.dev on Flutter. Every package is MIT licensed with zero third-party dependencies, so nothing else enters your build. A React Native or Flutter app installs one package that bridges to both native SDKs.
Configure
Call configure() once, as early in the app lifecycle as you can, with your SDK key and an onLink callback. That single call wires up cold start, warm start, and the deferred deep link check on first launch. Each of the three is opt-out with a flag when you would rather drive the flow yourself.
Handle the link
Your onLink callback receives every resolved link, whether the tap opened an app that was already installed or the link survived a store install. Check isDeferred to tell those two apart, then route to the screen the link named. The attribution result, with its match type and confidence score, lands on the same first launch.
One SDK call
import WarpLink
WarpLink.configure(
// SDK key from Keys > SDK
apiKey: "wl_live_yoursdkkeyhere000000000000000000",
options: WarpLinkOptions(onLink: { result in
guard case .success(let deepLink) = result, let deepLink else { return }
navigate(to: deepLink.destination)
})
)WarpLink.configure(
context = this,
// SDK key from Keys > SDK
apiKey = "wl_live_yoursdkkeyhere000000000000000000",
options = WarpLinkOptions(onLink = { result ->
result.onSuccess { deepLink -> navigateTo(deepLink.destination) }
result.onFailure { error -> Log.e("WarpLink", error.toString()) }
})
)import { WarpLink } from '@warplink/react-native'
WarpLink.configure({
// SDK key from Keys > SDK
apiKey: 'wl_live_yoursdkkeyhere000000000000000000',
onLink: ({ deepLink }) => {
if (deepLink) navigateTo(deepLink.destination)
},
})import 'package:warplink_flutter/warplink_flutter.dart';
// Call from your root widget's initState
WarpLink.configure(
// SDK key from Keys > SDK
apiKey: 'wl_live_yoursdkkeyhere000000000000000000',
onLink: (event) {
if (event is LinkEvent) {
navigateTo(event.deepLink.deepLinkUrl ?? event.deepLink.destination);
}
},
);Frequently Asked Questions
Yes. All four are MIT licensed, and the full source of each one lives in a public repository under the WarpLinkApp organization on GitHub, so you can read every line before you ship it, fork it, or send a fix back. Nothing about how a link resolves or how an install is matched sits hidden inside a binary.
All SDKs are under 200KB gzipped with zero third-party dependencies. The iOS SDK is distributed via SPM, Android via Maven Central, React Native via npm, and Flutter via pub.dev. Each is MIT licensed so you can inspect every line. How we measure this
Yes, with a development build. The SDK ships native modules, which Expo Go cannot load, so install it with expo install, run expo prebuild, then declare the associated domains and the intent filter in app.json. Add the iOS delegate calls with withAppDelegate in your own config plugin.
No. Install only the SDK for each platform you ship: a React Native app installs a single package, and a Flutter app installs the single warplink_flutter plugin, each bridging to both native SDKs, so neither needs the iOS and Android packages as well. One app in WarpLink holds the iOS and the Android configuration together, so shipping on both platforms still uses a single app from your plan. The plan limits are at warplink.app/pricing.
The device language and time zone, the vendor identifier (IDFV) on iOS or the Play Install Referrer on Android, your app identifier, the SDK version, and whether the app was reinstalled, over HTTPS with a WarpLink user agent that names the SDK version. On a tap it also sends the link's query string. The address the request came from is read server-side. It reads no advertising identifier, and the full field list is on the SDK data flow page.
Your links should open the app.
Your data should tell you why.
Set up deep linking, attribution, and analytics in minutes. Free to start.
Start building, freeHave a question?