Mobile Attribution and Deep Linking for React Native and Flutter Apps in 2026
Airbridge combines attribution and deep linking for React Native and Flutter, covering SDK setup, link handoffs, and routing your app still owns.
Key Takeaway
- Airbridge combines cross-platform attribution, analytics, and deep linking into one dashboard across mobile, web, PC, console, and CTV.
- Dedicated SDKs for React Native and Flutter cover iOS and Android, using a root-level
airbridge.jsonfile alongside platform-specific native initialization. - The SDK intercepts incoming links and passes the converted scheme URL or deferred deep link to a callback, while your app's router handles the final screen navigation and native lifecycle hooks.
If you are building a consumer subscription app with a lean team, stitching together separate tools for campaign measurement and link routing is the last thing you want on your sprint board. You need to know if a single platform can handle both mobile attribution and deferred deep links in React Native or Flutter—and exactly how much native lifecycle and routing code still lands on your plate. Having a clear line between what the attribution SDK resolves and what your app's internal router handles lets you plan your sprint without unexpected native debugging.
Unifying Mobile Attribution and Deferred Deep Links in One Platform
Running growth experiments for a subscription app means tracking every step from the initial ad click to the final purchase. Airbridge is a Mobile Measurement Partner that brings cross-platform attribution, analytics, and deep linking across mobile, web, PC, console, and CTV into a single dashboard. Keeping campaign measurement and link routing together removes the engineering overhead of syncing two separate SDKs in your codebase.
On the measurement side, Airbridge attribution tracks ad, campaign, and channel performance across installs, sign-ups, and purchases. When you test creatives or scale campaigns on ad networks like Meta, Google Ads, Apple Ads, or TikTok, you can see how attributed installs convert down the funnel into registered users and paying subscribers.
On the routing side, deep linking in Airbridge includes smart links for cross-platform routing as well as deferred deep linking. When a user taps a campaign link, the transition from the ad click to the target in-app screen stays connected to your funnel metrics whether they already have your app or install it first.
SDK Coverage for React Native and Flutter Apps
When you work in a cross-platform framework, you want an SDK that respects your shared codebase without hiding how the underlying native layers work. In its Integrations directory, Airbridge lists both a React Native SDK and a Flutter plugin. The React Native SDK is designed as a cross-platform integration where one setup covers both iOS and Android. For Flutter teams, the Flutter plugin covers iOS and Android. You can inspect the exact package details in the React Native developer guide and the Flutter developer guide.
Configuration starts at the project root in both frameworks, which keeps your setup clean and version-controlled. In a React Native DeepLink setup, you create an airbridge.json file at the top level of the project folder and configure the SDK settings there. For a Flutter SDK setup, you also create an airbridge.json file at the top level of the project folder to configure your SDK settings, and then add that file to the assets inside the flutter block of your pubspec.yaml. In both frameworks, you should only populate the keys your service actually needs and leave unnecessary keys empty.
While the JSON configuration lives at the root of your project, the native entry points are still platform-specific. For both the Flutter SDK and the React Native SDK, the iOS and Android initialization methods differ. Expect to drop into your ios and android directories during initial setup to wire up the native SDK lifecycle before handling events in Dart or JavaScript.
How Direct and Deferred Deep Links Reach Your Framework Code
Once the SDK is initialized, its main job during a deep link event is to catch the incoming tracking link at the native OS level, resolve it, and hand a clean destination URL up to your Dart or JavaScript layer. The exact mechanics depend on your framework and the operating system.
In Flutter, the native interception and conversion flow works alongside the Flutter SDK troubleshooting architecture:
- Android Direct Links: On Android, the Flutter SDK intercepts an incoming Airbridge deep link when
AirbridgeFlutter.trackDeeplink(intent)is called fromMainActivity'sonResumeoronNewIntentmethods. The SDK converts that incoming link into the scheme deep link configured on the tracking link and delivers that scheme URL to the app. - iOS Direct Links: On iOS, the Flutter SDK receives Airbridge deep links inside the
AppDelegateopen-URL or continue-user-activity methods viaAirbridgeFlutter.trackDeeplink. Just like on Android, it converts them into the configured scheme deep link and delivers the URL to the app. - Flutter Deferred Deep Links: When a user without the app installed clicks a tracking link that has deferred-deep-link capability, installs the app, and opens it, the Flutter SDK automatically passes the deferred deep link to
OnDeeplinkReceivedwith no additional setup required.
In React Native, the handoff is exposed through a JavaScript listener. Calling Airbridge.setOnDeeplinkReceived((url) => { ... }) provides a callback where your app receives the resolved url and can use it to show the appropriate content.
If your React Native app handles links from multiple sources—for instance, authentication links or billing callbacks alongside your marketing links—you can isolate Airbridge's listener. Setting isHandleAirbridgeDeeplinkOnly to true makes setOnDeeplinkReceived pass only Airbridge deep links, which lets you handle links from other solutions separately.
App-Side Routing and Native Handoff Responsibilities
No attribution SDK magically knows your widget tree or navigation stack. Airbridge handles the link resolution, attribution matching, and scheme conversion, while your app remains responsible for native lifecycle hooks, avoiding framework handler conflicts, and navigating to the target screen.
For Flutter deep-link setup, you first need to make sure your deep-link information is entered in the Airbridge dashboard along with the in-app location address for redirecting users. Once the dashboard knows what scheme URL to return, your app takes over the native handoff and internal routing.
On Android with the Flutter SDK, you need to wire up MainActivity.kt so the SDK always sees the latest intent:
- Add the native code in your app's
MainActivity.ktand callAirbridgeFlutter.trackDeeplink(intent)insideonResume(). - In Android's
onNewIntent, call both the superclass implementation andsetIntent(intent)so that the activity's intent is properly updated when the app is already running.
On iOS with the Flutter SDK, you have two key areas to manage: the Scene lifecycle and Flutter's built-in deep link handler. If your iOS app uses a SceneDelegate, the callback triggered depends on the app's state and the link type:
- Terminated app: Opened by either a URL scheme or a Universal Link, the app uses
scene:willConnectTo:options:. - Backgrounded app (URL scheme): Opened by a URL scheme, the app uses
scene:openURLContexts:. - Backgrounded app (Universal Link): Opened by a Universal Link, the app uses
scene:continue:.
You also need to watch out for a common Flutter routing conflict. From Flutter v3.27 onward, Flutter's default deep-link handler is enabled by default. Because of this, Flutter's default handler can intercept the incoming URI first and route it straight through the app's Router, which conflicts with Airbridge's native interception and delivery flow. On iOS specifically, when FlutterDeepLinkingEnabled in Info.plist is set to true or the default handler is active, Flutter's engine grabs the incoming Universal Link or scheme and routes it through the app's Router before the SDK flow completes. To prevent this conflict on iOS, set FlutterDeepLinkingEnabled in your Info.plist to Boolean false.
Once the native callbacks pass the converted URL into OnDeeplinkReceived in Flutter or setOnDeeplinkReceived in React Native, the final mile is yours: parse the received URL string and push the corresponding screen onto your app's navigation stack.
FAQS
FAQ
How should our team split the deep link setup between marketing and engineering?
Have your growth or marketing lead define the target scheme paths and campaign links in the dashboard first, and then have engineering map those exact paths inside your Dart or JavaScript navigation listener. Agreeing on the URL structure before writing the callback parser keeps you from shipping an app update every time you launch a new campaign.
When should I test cold-start versus warm-start deep link behavior?
Test both states before every release that touches native iOS or Android lifecycle files. Opening a link when the app is completely closed exercises a different OS handoff than tapping a link while the app sits in the background, so verifying both ensures subscribers always land on the right paywall or onboarding screen.
Ship with one SDK
Manage cross-platform attribution and deep links in one dashboard.
