Airbridge Migration

This guide is for teams currently using Airbridge for tracking links, deep linking, or install attribution who are moving to WarpLink. It covers Airbridge-specific concept mapping, exporting your existing tracking links and data, and swapping the Airbridge SDK for the WarpLink SDK on each platform.

For the provider-agnostic playbook (planning, domains, cutover, and decommissioning), see the general migration guide. This page covers only what is specific to leaving Airbridge.

Concept Mapping

1. Export Your Links

Tracking links via API. Airbridge's REST API includes a List Tracking Links endpoint and a Get a Tracking Link endpoint, authenticated with an API token you generate from Dashboard > Settings > Tokens.

Dashboard export. The Link Management view lets you download your full list of tracking links as a CSV file or a Google Sheet, capped at 10,000 tracking links per download.

Raw click and event data. Airbridge's Raw Data Export feature lets you pick an event and property template, a default preset or a fraud-check preset, and export it as CSV, or push it continuously to your own S3, Google Cloud Storage, BigQuery, or Snowflake destination. Raw data export is available on a higher Airbridge tier, not the entry-level tier most small teams start on.

2. Recreate Your Links

Recreate each Airbridge tracking link as a link in WarpLink via the dashboard or the REST API.

Parameter Mapping

Set utm_campaign and your other UTM values on each WarpLink link to carry them over. Reformat any deep link scheme that omits a path segment (yourscheme://?type=blog) to include one (yourscheme://blog?type=blog) before recreating it: Airbridge's own docs note that some ad platforms, Instagram specifically, do not process a schemeless-path deep link, and the requirement carries over regardless of provider.

Create via API

curl -X POST https://api.warplink.app/v1/links \
  -H "Authorization: Bearer wl_live_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "destination_url": "https://yourapp.com/product/123",
    "ios_url": "myapp://product/123",
    "android_url": "myapp://product/123",
    "ios_fallback_url": "https://apps.apple.com/app/id123456789",
    "android_fallback_url": "https://play.google.com/store/apps/details?id=com.example.myapp",
    "utm_campaign": "spring_sale"
  }'

3. Swap the SDK

// Package.swift
dependencies: [
    .package(url: "https://github.com/WarpLinkApp/warplink-ios-sdk", from: "1.2.0")
]

4. Update SDK Initialization

import Airbridge

let option = AirbridgeOptionBuilder(name: "YOUR_APP_NAME", token: "YOUR_APP_SDK_TOKEN").build()
Airbridge.initializeSDK(option: option)

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

5. Update Domain Configuration

- applinks:YOUR_APP_NAME.abr.ge
+ applinks:yourapp.aplnk.to

abr.ge is Airbridge-owned, so a link built on it cannot move with you: any abr.ge link must be reissued on a new domain. A custom domain is different. Airbridge requires you to own the domain yourself and set it up as a CNAME record at your own DNS provider, pointed at a Name/Value pair Airbridge supplies, so once your links exist on WarpLink you can repoint that same CNAME to WarpLink without needing Airbridge's permission or losing the domain. Airbridge does not document what happens to a cancelled account's CNAME target, so treat this as an active, deliberate DNS cutover rather than something to rely on continuing to resolve on its own. Airbridge accounts are limited to 2 custom domains, and reassigning the account's Display Domain retroactively rewrites the domain on every existing Airbridge tracking link, not just new ones, so account for that if your team is still actively managing domains on Airbridge during the transition.

Moving to a custom domain? Declare it to the SDK too: linkDomains at configure(), or the WarpLinkDomains plist key / app.warplink.DOMAINS manifest entry. See Use it in your app.

6. Migrate Deep Link Handling

The onLink callback set in step 4 already receives resolved links for cold start, warm start, and deferred installs.

func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
    WarpLink.open(url) // was Airbridge.trackDeeplink(url:) + handleDeeplink(url:onSuccess:)
    return true
}

func application(
    _ application: UIApplication,
    continue userActivity: NSUserActivity,
    restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
) -> Bool {
    WarpLink.continue(userActivity) // was Airbridge.trackDeeplink(userActivity:) + handleDeeplink(userActivity:onSuccess:)
    return true
}

7. Migrate Deferred Deep Links

WarpLink runs the deferred deep link check automatically from configure(). The match arrives in the same onLink callback, flagged with isDeferred. There is no separate deferred call to port.

On iOS, Airbridge delivers a deferred match through Airbridge.handleDeferredDeeplink(onSuccess:), a distinct call from the direct-tap handling in step 6. On Android, it is the separate Airbridge.handleDeferredDeeplink { uri -> ... } call. In React Native and Flutter, Airbridge does not distinguish the two at all: the same Airbridge.setOnDeeplinkReceived callback you deleted in step 6 already carried deferred matches too. Delete whichever of these calls remain in your code; WarpLink's onLink replaces all of them.

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

To run the check manually instead, set the deferred opt-out flag and call checkDeferredDeepLink() yourself (see the deferred deep link guides for iOS, Android, React Native, and Flutter).

8. Attribution and Reporting

WarpLink attributes installs to the link that drove them through a match cascade: an exact referrer signal (Play Install Referrer) on Android, an enriched probabilistic match on both platforms, and a device ID (IDFV) check on iOS that recognizes an install asking again, with a confidence score on every result. See the iOS attribution guide (or the Android, React Native, and Flutter equivalents) for match types, confidence bands, and privacy details.

Airbridge does not publish guidance for running its SDK alongside another provider during a migration off Airbridge. A couple of gotchas worth testing for during a dual-SDK window: any deep link scheme that reaches Airbridge without a path segment can already fail silently on platforms like Instagram, so check that behavior before assuming a broken link is a migration bug rather than a pre-existing one; and if your account still has two custom domains registered on Airbridge, changing the assigned Display Domain mid-migration rewrites every existing tracking link to the new domain, which can look like a WarpLink cutover problem when it is actually an Airbridge-side change.

Testing Checklist

After migration, verify on each platform:

• SDK initializes: enable debug logging and check console output
• Deep links open the app: tap a WarpLink URL on a physical device
• Deep link data resolves: destination and custom parameters are correct
• Deferred deep links work: click link, install, verify match. An uninstall is enough to retest on either platform, because the completion marker goes with the app. That second install is reported as a reinstall and still counts as an install
• AASA/assetlinks verified: curl https://yourapp.aplnk.to/.well-known/apple-app-site-association
• Error handling: test invalid URLs, expired links, no connectivity
• All Airbridge code removed: no remaining imports or dependencies
• Clean build: no compilation errors

Next Steps

• General migration guide: the provider-agnostic playbook for planning, domains, cutover, and decommissioning.
• Quickstart: create your first link and get an SDK key.
• iOS SDK, Android SDK, React Native SDK, and Flutter SDK: full setup and API reference.