WarpLink for Flutter: Deep Linking, Attribution, and Analytics in One Package

TL;DR: warplink_flutter 1.1.0 is on pub.dev. It gives Flutter apps the same deep linking, install attribution, and link analytics as the iOS, Android, and React Native SDKs. One onLink callback receives cold-start, warm-start, and deferred deep links, and setup needs no native code. Install it with flutter pub add warplink_flutter. The Flutter docs have the full guide.

WarpLink is link infrastructure for mobile teams: deep linking, install attribution, and real-time analytics in one SDK. The Flutter SDK is the fourth member of that family, and it ships at the same version as the other three: 1.1.0.

The package is warplink_flutter, published under the verified publisher warplink.app. It is MIT licensed, has zero third-party runtime dependencies, and the source lives in the public repository.

Everything the Other SDKs Do

The Flutter SDK wraps the native iOS and Android SDKs at version 1.1.0, so it behaves like them because it runs the same code underneath. You get:

• Deep links on cold start and warm start, for Universal Links and App Links.
• Deferred deep links, so a person who taps a link, installs the app, and opens it lands on the right screen.
• Install attribution, with deterministic matches flagged by matchGuaranteed.
• Link analytics, so each link resolve is recorded in your dashboard analytics.

Pass onLink to WarpLink.configure() and cold-start, warm-start, and deferred deep links all reach that one callback. deepLink.isDeferred tells you whether the link came from a tap or from a first launch after an install. Each tap is delivered at most once, and a newer tap replaces an older one that is still resolving.

Install and Quick Start

Add the package:

flutter pub add warplink_flutter

Then configure the SDK from the initState of your root widget. A cold-start link can arrive before the first frame, when no navigator exists yet, so navigateTo waits for it.

import 'dart:async';

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

final navigatorKey = GlobalKey<NavigatorState>();

void navigateTo(String url) {
  final navigator = navigatorKey.currentState;
  if (navigator != null) {
    navigator.pushNamed('/product', arguments: url);
    return;
  }
  // The first frame has not built the navigator yet.
  WidgetsBinding.instance.addPostFrameCallback((_) {
    navigatorKey.currentState?.pushNamed('/product', arguments: url);
  });
}

void main() => runApp(const App());

class App extends StatefulWidget {
  const App({super.key});

  @override
  State<App> createState() => _AppState();
}

class _AppState extends State<App> {
  @override
  void initState() {
    super.initState();
    unawaited(
      WarpLink.configure(
        apiKey: 'wl_live_yoursdkkeyhere000000000000000000',
        onLink: (event) {
          switch (event) {
            case LinkEvent(:final deepLink):
              // Fires for cold start, warm start, and deferred links.
              navigateTo(deepLink.deepLinkUrl ?? deepLink.destination);
            case ErrorEvent(:final error):
              debugPrint('WarpLink ${error.wireCode}: ${error.message}');
          }
        },
      ),
    );
  }

  @override
  Widget build(BuildContext context) => MaterialApp(
        navigatorKey: navigatorKey,
        routes: <String, WidgetBuilder>{
          '/': (context) => const Placeholder(),
          '/product': (context) => const Placeholder(),
        },
      );
}

The apiKey takes an SDK key, which you create under Keys in the dashboard. If your links use your own domain, pass it as linkDomains: ['links.yourapp.com'] so the SDK recognizes it on the very first launch.

Setup Is Configuration, Not Code

The plugin needs no AppDelegate, SceneDelegate, or MainActivity edits. You make three configuration changes:

1. iOS: add an Associated Domains entry, such as applinks:yourapp.aplnk.to (your app's own link host, shown in the dashboard under the app's Settings), to the Runner target.
2. Android: set minSdk to 26 and add an autoVerify intent filter for your link host.
3. Both: switch off Flutter's own deep-linking flag, so your router does not also receive the WarpLink URL as a route. onLink drives navigation instead.

The iOS side uses Swift Package Manager. Flutter 3.44 and later enable it by default. On Flutter 3.38 to 3.43, run flutter config --enable-swift-package-manager once. If you use go_router, call it from onLink. The Flutter docs cover each step, including the exact Info.plist and manifest entries.

Requirements

Requirement	Minimum
Flutter	3.38
Dart	3.10
iOS	15
Android	API 26

The plugin supports iOS and Android. On web and desktop, every call throws UnsupportedError.

Where to Go Next

The Flutter SDK guide walks through deep links, deferred deep links, attribution, and the API reference. The SDKs page compares what each package ships, and the package itself is on pub.dev. If you hit something the guide does not cover, open an issue on the GitHub repository.

Frequently Asked Questions

Which platforms and versions does the WarpLink Flutter SDK support? The SDK supports iOS 15 and later and Android API 26 and later. It needs Flutter 3.38 or later and Dart 3.10 or later. Web and desktop are not supported, and every call throws UnsupportedError there.

Do I need to edit AppDelegate, SceneDelegate, or MainActivity? No. The plugin registers itself for incoming links on both iOS life cycles and on Android. Setup is configuration only: an Associated Domains entry on iOS, an intent filter on Android with minSdk set to 26, and Flutter's own deep-linking flag switched off.

Does the WarpLink Flutter SDK work with go_router? Yes. Call your router from the onLink callback, and keep Flutter's own deep-linking flag off so the router does not also receive the WarpLink URL as a route. The Flutter docs include a go_router guide.

Does the SDK have third-party dependencies? No. warplink_flutter is MIT licensed and has zero third-party runtime dependencies. It wraps the WarpLink iOS and Android SDKs at version 1.1.0.

Related Guides

• The install side: Deferred Deep Linking on iOS and Deferred Deep Linking on Android explain the match cascade the Flutter SDK inherits.
• Before you ship: How to Test Deep Links on iOS and Android has the simulator and device commands.
• Campaign data: How to Pass UTM Parameters Through Deep Links Into Your App shows how link parameters reach the screen they open.