Skip to main content

🔥 Migrate from Firebase Dynamic Links

Google deprecated Firebase Dynamic Links and the service has been shut down. ChottuLink is a drop-in replacement that supports the same core capabilities — short links, deferred deep linking, platform-aware routing, and analytics — across more platforms.

What ChottuLink handles automatically

ChottuLink auto-generates and hosts your apple-app-site-association (iOS) and assetlinks.json (Android) files, manages HTTPS certificates, and handles domain verification — no manual server setup required.

🛠 Prerequisites​

Before you begin migrating, make sure you have the following ready:

  1. A ChottuLink account — Sign up for free if you haven't already
  2. Your Firebase Dynamic Links configuration — Note down your:
    • Firebase *.page.link domain (or custom domain)
    • iOS settings: Bundle ID, Team ID, App Store ID
    • Android settings: Package Name, SHA-256 fingerprints
    • Any existing short links you need to recreate
  3. Access to your app's codebase — You'll need to update SDK dependencies, configuration files, and code on all platforms
  4. A list of active Firebase links — Export destination URLs for any links you need to migrate (Firebase links stop working after the shutdown)
warning

Firebase Dynamic Links have been shut down. Existing *.page.link URLs no longer redirect. Start your migration as soon as possible to minimize user impact.

Migration Overview​

Once you have the above ready, follow these steps to complete the migration:

  1. Set up the ChottuLink Dashboard — Configure your project, choose your subdomain, and set up iOS/Android redirects (replaces Firebase Console setup)
  2. Migrate the SDK — Remove Firebase Dynamic Links SDK, install ChottuLink SDK, and update your app code
  3. Create your dynamic links on ChottuLink — Re-create your links using the Dashboard or REST API
  4. Handle deep link redirects inside your app — Update link receiving and handling code to use the ChottuLink SDK (covered in Step 2)
  5. Re-create your existing links — Bulk-migrate active Firebase links using the REST API or Dashboard

🗺️ Concept Mapping​

Use this table as a quick reference when migrating your codebase.

Terminology
Firebase Dynamic LinksChottuLinkNotes
Firebase projectChottuLink project / organizationCreated at app.chottulink.com
*.page.link domain*.chottu.link subdomainChosen during onboarding
Firebase ConsoleChottuLink Dashboardapp.chottulink.com
google-services.json / GoogleService-Info.plistMobile SDK API key (chottulink_xxx)Found under Dashboard > Keys
Firebase Web API KeyREST API key (c_api_xxx)Found under Dashboard > Keys
DynamicLinkParameters / DynamicLinkComponentsCLDynamicLinkBuilder (iOS) / ChottuLink.createDynamicLink() (Android)Builder pattern on both platforms
FirebaseDynamicLinks.getInstance().getDynamicLink()ChottuLink.getAppLinkData() (Android) / ChottuLinkDelegate (iOS)Receive & resolve links
socialMetaTagParameters.setSocialParameters(title:description:imageUrl:)First-class API on all platforms
Manual UTM in URL.setUTMParameters(source:medium:campaign:)Built-in SDK support

🔧 Step 1 — Set Up ChottuLink Dashboard​

Before changing any code, configure your project on the ChottuLink Dashboard. This replaces the Firebase Console configuration.

  1. Create an account at app.chottulink.com/register
  2. Choose a subdomain (e.g. yourapp.chottu.link) — this replaces your *.page.link domain
  3. Set a fallback URL — the default redirect when the app is not installed
  4. Configure iOS — Apple Team ID, Bundle Identifier, App Store ID, enable Universal Links → Full details: iOS Integration
  5. Configure Android — Package Name, SHA-256 fingerprints, enable App Links → Full details: Android Integration
  6. Copy your API keys from Dashboard > Keys
tip

ChottuLink uses two key types: a Mobile SDK key (chottulink_xxx) for client SDKs and a REST API key (c_api_xxx) for server-side calls. Firebase used a single API key for both — make sure you use the correct one.

For the full onboarding walkthrough, see the Getting Started guide.

📦 Step 2 — Migrate the SDK​

# If using CocoaPods, remove from Podfile:
# pod 'Firebase/DynamicLinks'
# Then run: pod install

# If using SPM, remove FirebaseDynamicLinks package from Xcode
  • Remove GoogleService-Info.plist if it was only used for Dynamic Links
  • Remove the old Associated Domain: applinks:yourapp.page.link

Add the SDK via Swift Package Manager:

https://github.com/ConnectingDotsInfotech/chottulink-ios-sdk.git

Or see iOS Installation for manual XCFramework setup.

Update Configuration​

In Xcode → Signing & Capabilities → Associated Domains, replace:

- applinks:yourapp.page.link
+ applinks:yourapp.chottu.link

Update Initialization​

// BEFORE (Firebase)
import Firebase
FirebaseApp.configure()

// AFTER (ChottuLink)
import ChottuLinkSDK

let config = CLConfiguration(apiKey: "your-mobile-sdk-key", delegate: self)
ChottuLink.initialize(config: config)
// BEFORE (Firebase)
guard let link = URL(string: "https://yourapp.com/content") else { return }
let components = DynamicLinkComponents(link: link, domainURIPrefix: "https://yourapp.page.link")
components?.iOSParameters = DynamicLinkIOSParameters(bundleID: "com.yourapp.ios")
components?.shorten { url, warnings, error in
    guard let shortURL = url else { return }
    // use shortURL
}

// AFTER (ChottuLink)
let builder = CLDynamicLinkBuilder(
    destinationURL: "https://yourapp.com/content",
    domain: "yourapp.chottu.link"
)
.setIOSBehaviour(.app)
.setAndroidBehaviour(.app)
.setLinkName("my-link")
.build()

Task {
    do {
        let shortURL = try await ChottuLink.createDynamicLink(for: builder)
        // use shortURL
    } catch {
        print("Error: \(error)")
    }
}
// BEFORE (Firebase)
func application(_ application: UIApplication, continue userActivity: NSUserActivity,
                 restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
    let handled = DynamicLinks.dynamicLinks().handleUniversalLink(userActivity.webpageURL!) { link, error in
        guard let deepLink = link?.url else { return }
        // handle deepLink
    }
    return handled
}

// AFTER (ChottuLink) — Implement ChottuLinkDelegate
func chottuLink(didResolveDeepLink link: URL, metadata: [String : Any]?) {
    print("Link received: \(link.absoluteString)")
    // Navigate based on link
}

func chottuLink(didFailToResolveDeepLink originalURL: URL?, error: any Error) {
    print("Error: \(error.localizedDescription)")
}

And in your SwiftUI view or SceneDelegate, forward links to the SDK:

.onOpenURL { url in
    ChottuLink.handleLink(url)
}

→ Full details: iOS Setup · Create Links · Receive Links

🌐 Step 3 — Migrate REST API Calls​

If you create or manage links from your backend, update your server-side integration.

Endpoint Mapping​

OperationFirebase Dynamic LinksChottuLink
Create short linkPOST firebasedynamiclinks.googleapis.com/v1/shortLinks?key={KEY}POST api2.chottulink.com/chotuCore/pa/v1/create-link
Get link analyticsGET firebasedynamiclinks.googleapis.com/v1/{shortLink}/linkStats?key={KEY}POST api2.chottulink.com/chotuCore/pa/v1/analytics

Authentication Change​

- # Firebase: API key as query parameter
- POST https://firebasedynamiclinks.googleapis.com/v1/shortLinks?key=YOUR_FIREBASE_KEY

+ # ChottuLink: API key as request header
+ POST https://api2.chottulink.com/chotuCore/pa/v1/create-link
+ API-KEY: c_api_xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
curl --location 'https://api2.chottulink.com/chotuCore/pa/v1/create-link' \
--header 'API-KEY: c_api_xxxxxxxxxxxxxxxxxxxxxxxxxxxxx' \
--header 'Content-Type: application/json' \
--data '{
    "domain": "yourapp.chottu.link",
    "destination_url": "https://yourapp.com/content",
    "link_name": "Summer Sale",
    "ios_behavior": 2,
    "android_behavior": 2,
    "utm_source": "email",
    "utm_medium": "newsletter",
    "utm_campaign": "summer2025"
}'

These REST API features were not available in Firebase Dynamic Links:

CapabilityEndpointDocs
List all links (paginated)GET .../pa/v1/links/pageList Links
Update link propertiesPATCH .../pa/v1/update-link/{linkId}Update Link
Enable / disable a linkPATCH .../pa/v1/links/change-status/{linkId}Enable/Disable
Get link info by short URLPOST .../pa/v1/links/infoGet Link Info
Install analytics (paid)POST .../pa/v1/install-analyticsInstall Analytics

For a ready-to-use API testing setup, import the ChottuLink Postman Collection.

🔗 Step 4 — Migrate Existing Links​

Existing Firebase links will stop working

URLs on *.page.link domains are no longer functional after the Firebase Dynamic Links shutdown. You must re-create critical links on ChottuLink and update all references (marketing emails, QR codes, social media posts, printed materials, etc.).

Strategy​

  1. Export your existing Firebase links and their destination URLs
  2. Bulk-create equivalent ChottuLink links using the REST API
  3. Update all references in your marketing materials, apps, and websites
curl --location 'https://api2.chottulink.com/chotuCore/pa/v1/create-link' \
--header 'API-KEY: c_api_xxxxxxxxxxxxxxxxxxxxxxxxxxxxx' \
--header 'Content-Type: application/json' \
--data '{
    "domain": "yourapp.chottu.link",
    "destination_url": "https://yourapp.com/promo",
    "link_name": "Summer Promo",
    "selected_path": "summer-promo",
    "ios_behavior": 2,
    "android_behavior": 2
}'

Bulk Migration Script (Python)​

Expand to see the migration script

Prepare a CSV file (links.csv) with your Firebase links:

firebase_link,destination_url,link_name,path
https://yourapp.page.link/abc,https://yourapp.com/promo,Summer Promo,summer-promo
https://yourapp.page.link/xyz,https://yourapp.com/refer,Referral,refer-friend

Then run this script:

import csv
import requests
import time

API_KEY = "c_api_xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
DOMAIN = "yourapp.chottu.link"
BASE_URL = "https://api2.chottulink.com/chotuCore/pa/v1/create-link"

headers = {
    "API-KEY": API_KEY,
    "Content-Type": "application/json"
}

with open("links.csv", newline="") as csvfile:
    reader = csv.DictReader(csvfile)
    for row in reader:
        payload = {
            "domain": DOMAIN,
            "destination_url": row["destination_url"],
            "link_name": row["link_name"],
            "selected_path": row["path"],
            "ios_behavior": 2,
            "android_behavior": 2,
        }

        response = requests.post(BASE_URL, json=payload, headers=headers)

        if response.status_code == 201:
            data = response.json()
            print(f"Created: {data['short_url']}  (was: {row['firebase_link']})")
        else:
            print(f"FAILED: {row['firebase_link']} -> {response.status_code} {response.text}")

        time.sleep(0.5)

✨ What's Better in ChottuLink​

ChottuLink is not just a Firebase replacement — it improves on several areas:

CapabilityFirebase Dynamic LinksChottuLink
Update links after creationNot supported (immutable)Supported via PATCH API
Enable / disable linksNot supportedSupported — pause campaigns without deleting
UTM parametersManual URL constructionFirst-class SDK and API support
Social previewsSeparate socialMetaTagParameters objectBuilt-in setSocialParameters() on all platforms
Install analyticsNot availableAvailable via API (paid plan)
Platform supportiOS, Android, Flutter, UnityiOS, Android, Flutter, React Native, Expo, Capacitor/Ionic, Unity
Custom link pathsLimitedFull control with selected_path

✅ Migration Checklist​

Use this checklist to track your migration progress:

  • Created ChottuLink account and configured project
  • Chose subdomain and set fallback URL
  • Configured iOS settings (Team ID, Bundle ID, Universal Links)
  • Configured Android settings (Package Name, SHA-256 fingerprints, App Links)
  • Removed Firebase Dynamic Links SDK from all platforms
  • Installed ChottuLink SDK on all platforms
  • Updated Associated Domains (iOS) and intent-filters (Android)
  • Updated SDK initialization code
  • Updated link creation code
  • Updated link receiving / handling code
  • Migrated server-side REST API calls
  • Re-created critical existing links via REST API
  • Tested deep links on both iOS and Android
  • Tested deferred deep links on both iOS and Android
  • Updated marketing materials, emails, and QR codes with new URLs

🧩 Troubleshooting​

For general deep linking issues, see the full Troubleshooting guide. Below are migration-specific tips.

Domain verification takes time After switching from *.page.link to *.chottu.link, both Apple and Google need time (minutes to hours) to verify the new domain. Be patient and test from a messaging app (WhatsApp, Telegram) rather than the browser URL bar.

Remove old Associated Domains If you leave applinks:yourapp.page.link in your iOS entitlements alongside the new ChottuLink domain, it can cause conflicts. Remove the old entry.

SHA-256 fingerprints must be complete Add all SHA-256 fingerprints (debug keystore, release keystore, and every developer's debug keystore) in the ChottuLink Dashboard. Missing fingerprints are the most common cause of Android App Links failing.

Deferred deep links not working Ensure the ChottuLink SDK is initialized before the first activity/screen loads. For Android, use ChottuLink.getAppLinkData(getIntent()) in the activity that launches right after the splash screen.

Play Store / App Store opens instead of the app This is expected for the first few hours after setup while domain verification completes. Use adb shell pm get-app-links <packageName> to check Android verification status. See the Troubleshooting guide for step-by-step verification instructions.

💬 Need Help?​

If you run into issues during migration:

  1. Chat with us on the ChottuLink Dashboard
  2. Email support at help@chottulink.com