# Open your app from old page.link links

> After this page, you will have an app build that opens from your old page.link links for people who already have your app, for as long as Google keeps serving page.link's app-link files. People without the app are not helped, and nobody can change that.

- Time: About 30 minutes, plus your next app release
- You need: Your app on the Strait SDK (unreleased versions, see step 2), your old page.link codes, the app release you are about to ship
- Works on: Android, iPhone (untested)

Source: https://straitlink.in/docs/migrate-from-firebase/page-link/

## What nobody can do

`page.link` belongs to Google. Its DNS, its certificate and every answer it gives are Google's. No provider, us included, can take it over or forward it. Today Google still redirects many old short links to their old destination and returns an error for others, and it can stop either at any time. On 9 October 2026, 21 of 26 real short links we tried still redirected, 5 returned 404, and long links (`/?link=…`) returned 400. Everything below is about people who **already have your app**.

## What still works, and why

Google still serves page.link's `apple-app-site-association` and `assetlinks.json` with each customer's app ID (checked on 9 October 2026 for taxfix, mybillbook, okcredit, adda247 and fabulaapp). So on a phone whose app build still lists your page.link domain, iOS and Android open the app on a tap **without asking Google's redirect**. The old Firebase SDK then asks Google what the link means and gets nothing. The Strait SDK can answer instead:

- a **short link** (`https://yourapp.page.link/aBcD`) is looked up in your workspace by its old host and code;
- a **long link** (`https://yourapp.page.link/?link=https://…&apn=…`) carries its destination inside the URL, so the SDK reads `link=` on the phone, with no network call.

This depends on things outside our control:

- **Google keeps serving those files.** It does today. Nothing says for how long. When it stops, the OS stops opening your app from page.link and these links go back to whatever Google answers.
- **The person updates your app.** A build that still has the Firebase SDK opens the app and then shows nothing. Only builds with the Strait SDK benefit.
- **Untested on real phones.** This path is covered by unit tests in every SDK. It has **not** been tested on a real iPhone yet, and the Android real-phone test is also still pending. Test it on your own devices before you rely on it.

## 1. Keep the page.link domain in your next build

**Do this:** don't remove it. Keep these next to your new `hilltop.strait.link` entries:

- **iOS:** Associated Domains keeps `applinks:yourapp.page.link`.
- **Android:** the manifest keeps the intent filter for `https://yourapp.page.link` (with `android:autoVerify="true"`, as Firebase had it).

**You should see:** `https://yourapp.page.link/.well-known/assetlinks.json` and `https://yourapp.page.link/apple-app-site-association` still list your package and app ID. If they return 404, Google has stopped serving them for your domain and this page can't help.

## 2. Add the host to linkHosts

**Do this:** add `linkHosts` with your old domain to your app's client. Page.link support is in React Native and Flutter 0.8.2, Android 0.7.3, and Swift and Unity 0.8.1 and later.

React Native:

```ts
const strait = createStrait({
  publishableKey: 'st_pub_live_…',
  endpoint: 'https://<your-handle>.strait.link',
  linkHosts: ['yourapp.page.link'],
  storage: AsyncStorage,
});
```

Flutter:

```dart
final strait = StraitLinks(
  publishableKey: 'st_pub_live_…',
  endpoint: 'https://<your-handle>.strait.link',
  linkHosts: const ['yourapp.page.link'],
  // platform, storage… as in the Flutter guide
);
```

Android (Kotlin):

```kotlin
strait = StraitClient(StraitConfig(
    publishableKey = "st_pub_live_…",
    endpoint = "https://<your-handle>.strait.link",
    linkHosts = listOf("yourapp.page.link"),
    // storage… as in the Android guide
))
```

Swift:

```swift
let strait = StraitLinks(StraitLinksConfig(
    publishableKey: "st_pub_live_…",
    endpoint: "https://<your-handle>.strait.link",
    linkHosts: ["yourapp.page.link"]
))
```

Unity (C#):

```csharp
Client = new StraitClient(new StraitConfig
{
    PublishableKey = "st_pub_live_…",
    Endpoint = "https://<your-handle>.strait.link",
    LinkHosts = { "yourapp.page.link" },
    // Storage, Platform… as in the Unity guide
});
```

Your `onLink` handler needs no change.

**You should see:** a tap on `https://yourapp.page.link/?link=https://yourapp.com/p/42` (a long link) opens the app on `/p/42` with no lookup.

## 3. Import your old codes

**Do this:** in **Dashboard → Import → Firebase import**, paste your old links (`https://yourapp.page.link/aBcD?link=…`, or a CSV). Each imported link keeps its **old host and code**. The app's lookup matches host and code first, so `aBcD` from `yourapp.page.link` and `aBcD` from `otherapp.page.link`, or an old code and a new Strait slug, never clash. If the code is already a slug here, the link gets another slug and the old URL still finds it.

The importer also keeps fallbacks (`afl`, `ifl`, `ofl`), the social preview (`st`, `sd`, `si`) and `utm_*`.

**You should see:** the imported links in **Dashboard → Links**, each showing the page.link URL it came from.

### Don't have the destinations? Recover from page.link

Paste your old page.link codes. While Google still answers a code, we read where it pointed and fill in the new link for you. Codes Google has already dropped can't be recovered by anyone; enter those destinations yourself.

The **Recover from page.link** tab in the import page reads Google's Firebase debug page (`?d=1`), which is an **undocumented Google format**: it works only while Google still answers and can stop at any time. Before it fetches anything, it checks that your page.link host's `apple-app-site-association` or `assetlinks.json` names your workspace's own app ID or package, so nobody can use it to read another company's links. It runs only when you press the button, at about one request per second.

## 4. Test on your own phones

**Do this:** with the new build installed, tap an old short link and an old long link from a chat or email app (not the address bar). The app should open on the right screen. Without the app you get whatever Google serves.

**You should see:** each tap in **Dashboard → Analytics** as an app open.

## Common errors

- **The app opens and shows nothing.** The build still runs the Firebase SDK, or `yourapp.page.link` is missing from `linkHosts`.
- **The browser opens instead of the app.** The build dropped the page.link domain, or Google no longer serves its app-link files for your domain (check step 1).
- **`not_found` on a short link.** That code was never imported. Import it, or recover it while Google still answers.

## Next steps

- [Import and cut over](https://straitlink.in/docs/migrate-from-firebase/cutover/): put the same links on your own link domain and replace page.link wherever you control the text.
- Used your own domain with Firebase Dynamic Links? Import your old links with the same paths. You can send that domain's traffic to Strait today with a redirect in your Firebase Hosting settings. Custom domains on Strait are coming soon; then you point the domain at us and the old paths work as before.