Migrating Firebase Dynamic Links to Branch Links

Overview

Google has announced the deprecation of Firebase Dynamic Links, but fortunately, Branch has made it straightforward to transition from Firebase Dynamic Links to Branch Links. This means you can continue creating the best experience for your users while ensuring your marketing efforts are effectively driving new customers to your app.

Custom Domain vs Default Domain

Depending on whether or not you have used a custom domain with Firebase, there are a few different options when it comes to migrating to Branch Links.

Custom Firebase Domain

If you used a custom domain with Firebase, you have the option to use the same custom domain with Branch, or a different domain.

Same Custom Domain With Branch

The benefit of using the same custom domain with Branch that you had with Firebase is that you won't need to worry about replacing links, because Branch can replicate the exact same functionality of the existing links. Also, if you've used QR Codes, you won't need to reprint them because the same links will work with Branch.

To ensure that you do not need to replace any of your existing links, make sure to create Branch Links with the exact same alias as the one you used with Firebase.

Please note that if you choose this approach, there will be a small amount of downtime when you switch the CNAME of the custom domain from Firebase to Branch.

Different Domain With Branch

If you used a custom domain with Firebase but want to use a different domain with Branch, you will need to replace any existing links in circulation with new Branch Links that you create.

Default Firebase Domain

If you used the default Firebase domain (`page.link`), you will need to transition to using Branch's default app.link domain or use a custom domain with Branch. There is no way to continue using page.link with Branch.

Please note that this mean  you will need to replace any existing links in circulation with new Branch Links that you create.

Prerequisites

If you are using Firebase Dynamic Links without the Firebase SDK, you can skip to Step 5.

Otherwise, in order to start migrating your Firebase Dynamic Links to Branch Links, you need to have the following:

1. Developer resources for your mobile app.

2. The ability to identify your existing Firebase Dynamic Links.

Migrate from Dynamic Links to Branch Links

Using Firebase and Branch Side-by-Side

It is possible to implement Branch SDKs alongside the Firebase SDK you already have implemented, and to start using Branch Links that way. This lets you ensure that your users have a seamless experience and that you can continue handling Firebase Dynamic Links out in the wild. This may be especially important if you are also using Firebase for other use cases, like authentication.

WARNING: Using the Branch iOS SDK alongside the Firebase SDK will cause issues unless you disable method swizzling with the FirebaseAppDelegateProxyEnabled flag (learn more here). In this case, Branch recommends either removing the Firebase SDK entirely before integrating the Branch iOS SDK, or disabling method swizzling.

1. Create & Configure your Branch Dashboard Account

Go to https://dashboard.branch.io/ and create an account. After creating your account navigate to the Configuration page to start configuring your app settings.

Set your Redirects

In the Required Redirects section, set your redirects per platform, and specify the correct app configuration settings.

Set your Social Media Preview

In the Social Media Preview section, set your title, description, and thumbnail image.

Establish your Link Domain

In the Link Domain section, set your Default Link Domain or set a custom domain.

For additional details on configuring your Branch Dashboard, view our guide here.

2. Integrate the Branch SDK & Set Up Deep Linked Routing

We have full guides on integrating the Branch SDK into your mobile app. Follow these guides based on your platform of choice:

• Native Platforms:

  • Android

  • iOS

• Plugins/Wrappers:

  • Adobe Launch (Android | iOS)

  • Capacitor

  • Cordova PhoneGap Ionic

  • Flutter

  • mParticle (Android | iOS)

  • React Native

  • Unity

  • Xamarin (Android | iOS)

Additional Deep Linked Routing Resources

The integration guides above go through setting up deep linked routing for your app. We also have additional resources on in-app routing that can be found here.

3. Verify Branch Links

During the integration process, you should have gone through testing your Branch Links. By now you should be able to do the following with Branch Links:

• Branch Link click can redirect to your website and relevant mobile app store listings if the app is not installed or if it's a web-only link.

• Branch Link click opens your mobile app if the app is installed.

• Branch Link click can deep link into specific in-app content if the app is installed.

4. Understand Parameter Mapping

Before migrating Dynamic Links to Branch Links, it's important to understand how different parameters are mapped between Firebase and Branch. If your Dynamic Links are utilizing specific parameters for certain behaviors or analytics, use the following table to determine which Branch parameter you will need to achieve the same result:

No Branch Parameter

For some Firebase parameters, there isn't an equivalent Branch parameter. This is because Branch does not require that parameter to achieve that behavior; it is automatically determined in your Dashboard Configuration.

5. Migrating Links Created from the Firebase Console

Firebase Dynamic Links created in the Firebase console are useful for creating promo links to share on social media through a user interface.

To create the equivalent Branch Link, utilize the Branch Dashboard to create a Quick Link:

6. Migrating Links Created from the Dynamic Link Builder API

Firebase Dynamic Links created through the Firebase Dynamic Builder API (iOS | Android | Flutter) are useful for programmatically creating links in your app for user-to-user sharing or in any situation that requires many links.

guard let link = URL(string: "https://www.example.com/my-page") else { return }
let dynamicLinksDomainURIPrefix = "https://example.com/link"
let linkBuilder = DynamicLinkComponents(link: link, domainURIPrefix: dynamicLinksDomainURIPRefix)
linkBuilder.iOSParameters = DynamicLinkIOSParameters(bundleID: "com.example.ios")
linkBuilder.androidParameters = DynamicLinkAndroidParameters(packageName: "com.example.android")

guard let longDynamicLink = linkBuilder.url else { return }
print("The long URL is: \(longDynamicLink)")

NSURL *link = [[NSURL alloc] initWithString:@"https://www.example.com/my-page"];
NSString *dynamicLinksDomainURIPrefix = @"https://example.com/link";
FIRDynamicLinkComponents *linkBuilder = [[FIRDynamicLinkComponents alloc]
                                         initWithLink:link
                                               domainURIPrefix:dynamicLinksDomainURIPrefix];
linkBuilder.iOSParameters = [[FIRDynamicLinkIOSParameters alloc]
                             initWithBundleID:@"com.example.ios"];
linkBuilder.androidParameters = [[FIRDynamicLinkAndroidParameters alloc]
                                 initWithPackageName:@"com.example.android"];

NSLog(@"The long URL is: %@", linkBuilder.url);

val dynamicLink = Firebase.dynamicLinks.dynamicLink {
    link = Uri.parse("https://www.example.com/")
    domainUriPrefix = "https://example.page.link"
    // Open links with this app on Android
    androidParameters { }
    // Open links with com.example.ios on iOS
    iosParameters("com.example.ios") { }
}

val dynamicLinkUri = dynamicLink.uri

DynamicLink dynamicLink = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLink(Uri.parse("https://www.example.com/"))
        .setDomainUriPrefix("https://example.page.link")
        // Open links with this app on Android
        .setAndroidParameters(new DynamicLink.AndroidParameters.Builder().build())
        // Open links with com.example.ios on iOS
        .setIosParameters(new DynamicLink.IosParameters.Builder("com.example.ios").build())
        .buildDynamicLink();

Uri dynamicLinkUri = dynamicLink.getUri();

final dynamicLinkParams = DynamicLinkParameters(
  link: Uri.parse("https://www.example.com/"),
  uriPrefix: "https://example.page.link",
  androidParameters: const AndroidParameters(packageName: "com.example.app.android"),
  iosParameters: const IOSParameters(bundleId: "com.example.app.ios"),
);
final dynamicLink =
    await FirebaseDynamicLinks.instance.buildLink(dynamicLinkParams);

To create the equivalent Branch Link, utilize Branch's relevant SDK methods (iOS | Android | Flutter):

buo.getShortUrl(with: lp) { url, error in
    print(url ?? "")
}

[buo getShortUrlWithLinkProperties:lp andCallback:^(NSString* url, NSError* error) {
    if (!error) {
        NSLog(@"@", url);
    }
}];

val lp = LinkProperties()
        .setChannel("facebook")
        .setFeature("sharing")
        .setCampaign("content 123 launch")
        .setStage("new user")
        .addControlParameter("$desktop_url", "http://example.com/home")
        .addControlParameter("custom", "data")
        .addControlParameter("custom_random", Long.toString(Calendar.getInstance().getTimeInMillis()))

    buo.generateShortUrl(this, lp, BranchLinkCreateListener { url?, error? ->
        if (error == null) {
            Log.i("BRANCH SDK", "got my Branch link to share: " + url)
        }
    })

LinkProperties lp = new LinkProperties()
        .setChannel("facebook")
        .setFeature("sharing")
        .setCampaign("content 123 launch")
        .setStage("new user")
        .addControlParameter("$desktop_url", "https://example.com/home")
        .addControlParameter("custom", "data")
        .addControlParameter("custom_random", Long.toString(Calendar.getInstance().getTimeInMillis()));

    buo.generateShortUrl(this, lp, new Branch.BranchLinkCreateListener() {
        @Override
        public void onLinkCreate(String url, BranchError error) {
            if (error == null) {
                Log.i("BRANCH SDK", "got my Branch link to share: " + url);
            }
        }
    });

BranchUniversalObject buo = BranchUniversalObject(
  canonicalIdentifier: 'flutter/branch',
  //canonicalUrl: '',
  title: 'Flutter Branch Plugin',
  imageUrl: 'https://flutter.dev/assets/flutter-lockup-4cb0ee072ab312e59784d9fbf4fb7ad42688a7fdaea1270ccf6bbf4f34b7e03f.svg',
  contentDescription: 'Flutter Branch Description',
  keywords: ['Plugin', 'Branch', 'Flutter'],
  publiclyIndex: true,
  locallyIndex: true,
  contentMetadata: BranchContentMetaData()..addCustomMetadata('custom_string', 'abc')
  ..addCustomMetadata('custom_number', 12345)
  ..addCustomMetadata('custom_bool', true)
  ..addCustomMetadata('custom_list_number', [1,2,3,4,5 ])
  ..addCustomMetadata('custom_list_string', ['a', 'b', 'c']),
);

BranchLinkProperties lp = BranchLinkProperties(
  //alias: 'flutterplugin', //define link url,
  channel: 'facebook',
  feature: 'sharing',
  stage: 'new share',
  tags: ['one', 'two', 'three']
);
lp.addControlParam('url', 'http://www.google.com');
lp.addControlParam('url2', 'http://flutter.dev');

BranchResponse response =
  await FlutterBranchSdk.getShortUrl(buo: buo, linkProperties: lp);
if (response.success) {
  print('Link generated: ${response.result}');
} else {
  print('Error : ${response.errorCode} - ${response.errorMessage}');
}

7. Migrating Links Created from the REST API

Firebase Dynamic Links created through the Firebase REST API are useful for dynamically creating links on platforms that don't have a Builder API.

POST https://firebasedynamiclinks.googleapis.com/v1/shortLinks?key=api_key
Content-Type: application/json

{
  "dynamicLinkInfo": {
    "domainUriPrefix": "https://example.page.link",
    "link": "https://www.example.com/",
    "androidInfo": {
      "androidPackageName": "com.example.android"
    },
    "iosInfo": {
      "iosBundleId": "com.example.ios"
    }
  }
}

To create the equivalent Branch Link, utilize Branch's Deep Link API:

POST /v1/url HTTP/1.1
Accept: application/json
Content-Type: application/json
Host: api2.branch.io
Content-Length: 710

{"branch_key":"key_live_xxxx","channel":"facebook","feature":"onboarding","campaign":"new product","stage":"new user","tags":["one"],"data":{"$fallback_url":"string","$fallback_url_xx":"string","$desktop_url":"string","$ios_url":"string","$ios_url_xx":"string","$ipad_url":"string","$android_url":"string","$android_url_xx":"string","$samsung_url":"string","$huawei_url":"string","$windows_phone_url":"string","$blackberry_url":"string","$fire_url":"string","$ios_wechat_url":"string","$android_wechat_url":"string","$web_only":false,"$desktop_web_only":false,"$mobile_web_only":false,"$after_click_url":"false","$afterclick_desktop_url":"string"},"alias":"string","type":0,"duration":7200,"identity":"string"}

8. Migrating Long Links Manually

Firebase Dynamic Links created manually are useful if you don't need to track click data and don't care if links are long:

https://your_subdomain.page.link/?link=your_deep_link&st=your_title&sd=your_description

To create the equivalent Branch Link, utilize Branch's Long Links:

https://your_subdomain.app.link/?$canonical_url=your_deep_link&$og_title=your_title&$og_description=your_description

Additional Branch Link Creation Options

There are other methods of creating Branch Links that may better align with your marketing strategies and processes. Some of these options can help make your migration easier through bulk creation. View some of those options here: