Some page.link links now 404, the rest lost their deep links: a migration checklist
Firebase Dynamic Links shut down on 25 August 2025. Some page.link URLs now return a 404, long links fail, and Google no longer opens your app from the ones that still redirect. Here is a checklist for finding the old links, replacing them, and moving deep links and deferred links to a new service.
If a user taps an old yourapp.page.link/… link today, it no longer does what a Dynamic Link did. Firebase Dynamic Links (FDL) shut down on 25 August 2025. Google's FAQ said that links "will stop working" and that clicked links would return HTTP 404. What we saw when we requested real page.link URLs on 5 October 2026 is messier:
- Some short links return 404, with a page titled "Dynamic Link Not Found".
- Some short links still answer with a plain
302redirect to their web fallback or Play Store URL. - A long link (
?link=…&apn=…) returned400("Invalid Dynamic Link - Blocked").
What is gone for every link: opening the app, the deferred route through an install, analytics, and creating new links. A short link that still redirects is just a plain redirect now, and Google could stop it at any time.
This post is a working checklist for the cleanup: where old links hide, what you can and can't rescue, and what to put in place so the next link you share opens the right screen again. It assumes you've already picked a replacement or are about to. If you haven't, start with our comparison of Firebase Dynamic Links alternatives. For what still works today and for how long, read Firebase Dynamic Links shutdown: what still works.
What actually broke
Google's Dynamic Links deprecation FAQ is short and clear. Four things matter for the cleanup:
- The service is shut down. Google's FAQ says links served by FDL, on page.link subdomains and on custom domains, "will stop working" and that clicked links return a 404. In our checks some short links do 404, long links fail with 400, and some short links still do a plain redirect to their fallback. Either way the Dynamic Link behaviour is gone: no opening the app, no deferred deep link through an install, no analytics. Don't count on the plain redirects lasting.
- The page.link domains are gone. The FAQ says that once the service shut down,
.page.linkdomains are no longer available. They can't be transferred to you or to anyone else. - The APIs stopped too. Calls to the Short Links API and the Link Stats API now get
400or403errors. If your backend created links on the fly (for invites, shares or receipts), that code now fails. - Google's suggested replacement is split in two. For deep links into an installed app, Google points to Android App Links and iOS Universal Links. For everything else FDL did (deferred deep links, link previews, analytics), it points to third-party providers.
You can check what any old link does today yourself:
curl -s -o /dev/null -w '%{http_code} %{redirect_url}\n' https://yourapp.page.link/abc
# 404 → the link is gone
# 302 https://example.com/… → a plain redirect to the fallback; the app-opening part is goneThe one thing you can't fix
You can't redirect a page.link URL yourself. The domain belongs to Google, the service behind it is shut down, and no provider can take it over. Whatever an old short link does today (a 404, or a plain redirect Google may stop at any time) is out of your hands. A provider that says old page.link links keep working can mean only two things: links on a custom domain that you own and that FDL used to serve, where you can point DNS somewhere new, or opening your app for people who already have it, from an app build that keeps the page.link domain (how).
So the cleanup has two halves:
- page.link URLs: replace them everywhere you still control the text.
- Custom-domain FDL links: if you own the domain, you can point it at a new service and recreate the paths. (On Strait, custom domains are live on Starter and up: Custom domains. Every workspace also gets its own
<handle>.strait.linksubdomain.)
Checklist 1: find where old links live
Old links hide in more places than the codebase. Work through these, roughly in order of how many taps they get:
Your app's own share code. Search the repo for the domain and the SDK:
Terminal grep -rn "page.link" --include=*.{ts,tsx,js,kt,java,swift,dart,json,xml,plist} . grep -rn "dynamic_links\|DynamicLinks\|dynamic-links" .Backend code that creates links. Anything calling the Firebase Short Links REST API is now failing. Look for
firebasedynamiclinks.googleapis.comin server code and in environment configs.Push and email templates. CRM tools, marketing automation and transactional email templates often have page.link URLs pasted in by hand. Export the templates and search them.
SMS templates. In India, DLT-registered SMS templates are especially painful because a new URL can mean re-registering the template. List them early.
QR codes. Printed packaging, posters, table tents and invoices. You can't change a printed QR code, so note where each one points, and decide whether to reprint or accept the loss.
Store listings and social profiles. App Store and Google Play descriptions, Instagram and X bios, YouTube descriptions, pinned posts.
Help center and website. FAQ articles, footers and "get the app" buttons.
Partners and affiliates. Links you handed to influencers or partners who may still be posting them.
Write each one down with its current URL and the screen it should open. That list becomes your import file.
Checklist 2: recreate the links
Most services can import links in bulk. On Strait you paste them into Dashboard → Import, in any of these forms:
- Firebase short links with the long form attached, for example
https://yourapp.page.link/abc?link=https%3A%2F%2Fshop.example.com%2Fp%2F42 - Plain destination URLs, one per line
- A CSV with a header row (
link,url,destinationorlongUrlfor the destination;slug,short,pathorkeyfor the short code)
short,link
https://yourapp.page.link/summer,https://shop.example.com/product/42
https://yourapp.page.link/invite,https://shop.example.com/invite?ref=abcWe pull the real destination out of each Firebase link's link= parameter, keep the old short code as the new slug where we can, and show a preview with any rows that can't be imported, and why, before anything is created. That keeps paths like /summer and /invite the same, which matters when you can repoint a custom domain later.
Map the FDL parameters you used to the new fields as you go:
| Firebase Dynamic Links | Strait |
|---|---|
link= (the deep link) |
The link's destination (longUrl) |
afl, ifl (fallbacks) |
androidFallbackUrl, iosFallbackUrl |
st, sd, si (social preview) |
title, description, imageUrl |
utm_* campaign parameters |
UTM parameters and campaign |
Checklist 3: swap the SDK in the app
Removing the retired SDK is quick. The package names to look for:
- Flutter:
firebase_dynamic_linksinpubspec.yaml - React Native:
@react-native-firebase/dynamic-links - Android:
com.google.firebase:firebase-dynamic-links - iOS: the
FirebaseDynamicLinkspod or Swift package product
Then route on the new SDK's callback the same way you routed on the dynamic link. In Flutter, for example:
- FirebaseDynamicLinks.instance.onLink.listen((data) => route(data.link));
+ links.onLink.listen((e) { if (e.matched && e.path != null) route(e.path!, e.params); });One callback handles both cases: a tap that opens the installed app, and the first open after an install (the deferred case). On Android, Strait carries the link through the install with Google Play's install referrer, so the first open lands on the right screen without guessing. On iPhone, deferred matching is opt-in. Our SDK guides cover each platform.
Checklist 4: update verification, then check it
Your app was verified for yourapp.page.link. It now needs to be verified for the new domain, or taps will open the browser instead of the app.
- Android: change the intent filter's
android:hostto the new host, keepandroid:autoVerify="true", and list every signing certificate's SHA-256 fingerprint (debug, upload, and the Play App Signing key) in your link service's settings. - iPhone: change Associated Domains to
applinks:<new host>, and save your Team ID and bundle ID.
Then check the two files the phone reads. Paste your new link domain into the free App Links checker: it fetches assetlinks.json and apple-app-site-association and explains anything wrong (a missing file, a redirect, the wrong content type, a malformed fingerprint or app ID). If Android still won't verify, our post on the SHA-256 mistakes that break App Links walks through the usual causes.
Checklist 5: think about old app versions
This step is easy to miss. People who haven't updated your app still have the old intent filters and Associated Domains, which mention page.link and not your new host. A link on the new domain won't open those old versions directly.
What happens instead depends on the service. On Strait, a tap that can't open the app goes to the store or your website, depending on your setting, so nobody hits a dead end. Two habits reduce the gap:
- Ship the new release first, then switch the links in your templates.
- Keep the custom scheme (
yourapp://) registered in the app. When a tap reaches our server in a browser, we can hand the link to the app through the scheme even when the domain isn't verified for that version.
Checklist 6: replace the backend calls
Wherever your server called the Firebase Short Links API, call the new service's API instead. On Strait that's POST /v1/links with a secret key (or the Node SDK):
curl https://strait.link/v1/links \
-H "Authorization: Bearer $SECRET_KEY" \
-H "Content-Type: application/json" \
-d '{"slug":"invite-abc","longUrl":"https://shop.example.com/invite?ref=abc"}'Keep the secret key on the server. Apps and websites use the publishable key, which only works with the SDK endpoints and cannot create or change links.
Checklist 7: verify on a real phone
Don't trust a desktop browser for this. Install the release build, then tap each kind of link from a chat or email app (pasting a link into an address bar never opens an app):
- App installed and closed: the link should open the right screen.
- App in the background: same.
- App not installed: the store (or your website), then the right screen on first open after a Play install.
This is the same set of scenarios our own real-phone suite runs before each release, on an Android phone driven over adb.
A short version to paste into your team's tracker
- List every page.link URL: app code, backend, push, email, SMS, QR, store listings, bios, help center, partners
- Import the links into the new service, keeping slugs
- Remove the Firebase Dynamic Links SDK; route on the new callback
- Update Android intent filters and iOS Associated Domains; add all SHA-256 fingerprints
- Check the files with the App Links checker
- Ship the release, then swap links in templates
- Replace Short Links API calls with the new API
- Test on a real phone: installed, background, not installed
The full step-by-step guide, with code for every platform, is in the docs: Migrate from Firebase Dynamic Links.
Sources and how we checked
- Google, Firebase Dynamic Links deprecation FAQ: shutdown date, the stated 404 response, page.link domains no longer available, API errors, and Google's recommended alternatives. Read on 5 October 2026.
- Our own requests to real page.link URLs on 5 October 2026 with
curl: some short links returned HTTP 404 ("Dynamic Link Not Found"), others returned a plain302to their web or Play Store fallback, and a long?link=…&apn=…link returned400. - Strait import, SDK and verification behaviour as documented in our migration guide, App Links docs and deferred deep linking docs.