# Samsung Internet opens the Play Store instead of your app: the intent:// link issue

> A deep link that works in Chrome sends Samsung Internet users to Google Play even though the app is installed. Here is how Android intent:// links work, the user-gesture rule behind the problem, what we saw on a real phone, and the fixes that hold up.

Source: https://straitlink.in/blog/samsung-internet-intent-link-opens-play-store/

Here is a bug report that turns up in deep-linking work. A user on a Galaxy phone taps your link in a text message. The app is installed, but instead of opening it, the phone opens Google Play on your app's page with an **Open** button. In Chrome, the same link opens the app right away. Nothing in your server logs looks wrong.

This post explains why that happens. It covers how Android's `intent://` links work, the browser rule that decides whether one can open an app, what we saw when we tested Samsung Internet on a real phone, and the fixes that remove the problem instead of hiding it.

## How a deep link reaches an Android app through a browser

There are two ways an Android link can open your app.

1. **Verified App Links.** You publish `/.well-known/assetlinks.json` on your link domain, and your app declares an intent filter with `android:autoVerify="true"`. When a link on that domain is handed to Android, Android opens your app directly. **No browser is involved**, so the browser's rules don't apply. ([Android: App Links](https://developer.android.com/training/app-links))
2. **A browser hand-off.** If the link isn't verified, or the person is already in a browser, the browser loads the URL. The link server then answers with something the browser can use to open the app. On Android that's usually an **intent URL**.

An intent URL looks like this. It's the shape our engine's URL builder produces (a real one also carries a tap id, left out here):

```txt
intent://shop.example.com/sale/summer#Intent;scheme=https;package=com.example.hilltop;S.browser_fallback_url=https%3A%2F%2Fplay.google.com%2Fstore%2Fapps%2Fdetails%3Fid%3Dcom.example.hilltop;end
```

Reading it from left to right:

- `intent://shop.example.com/sale/summer` is the deep link (host and path) the app should open.
- `scheme=` is the scheme the app registered.
- `package=` names the app that should handle it.
- `S.browser_fallback_url=` is where the browser goes if it can't open the app, for example Google Play with the link attached.

Chrome documents this format in [Android Intents with Chrome](https://developer.chrome.com/docs/android/intents). Two lines in that page matter here. First, Chrome strips `S.browser_fallback_url` before handing the intent to the app. Second, Chrome **won't launch an external app** for an intent URL in some cases. These include when the intent can't be resolved, when a JavaScript timer tries to open an app without a user gesture, when the intent URL comes from a redirect of a typed-in URL, and when the intent URL is initiated **without a user gesture**.

That last rule is the whole story. A browser that won't launch the app follows the fallback URL instead. If your fallback is Google Play, users land in Play, even with the app installed.

## What we saw on a real phone

We test browser hand-offs on a real Android phone (Android 16) with Chrome, Samsung Internet, Firefox and Edge installed. Two kinds of run matter here.

**A tap inside the browser.** Our scripted real-phone suite, which lives in our sample app's repository (`scripts/analytics-test.sh`), opens a test page in Samsung Internet and taps a link on it. The link server answers with the intent URL, and the app opens on the right screen. The suite then checks the database: one tap recorded with `sent_to = app_or_store`, and one app open joined to that tap. Samsung Internet passes that check the same way Chrome does. When the app isn't installed, the same flow goes to Google Play, as it should.

**A link handed to the browser from another app, with no tap inside it.** On 3 October 2026 we opened an unverified link in Samsung Internet (version 30) from outside the browser, the way a messaging app does when your App Links aren't verified. The browser loaded our link server, received the intent URL, and **went to the Play fallback even though the app was installed**. Chrome behaves differently on that path: the same suite hands a link to Chrome from outside the browser, with no tap inside it, and Chrome opens the app through the intent URL. That check passes on every run. For Samsung Internet the suite has to tap a link on a page instead.

Our reading: Samsung Internet saw no user gesture inside the browser. The page navigation began in another app, so it treated the intent URL as initiated without a gesture and declined to launch the app, which is the kind of case Chrome's documentation describes. Chrome evidently counts a link handed over by another app as user-initiated; Samsung Internet, in our test, did not. This is an observation from one phone (not a Samsung Galaxy) and one browser version, so treat it as a strong hint rather than a specification. It does explain the bug report at the top of this post.

## Why it mostly hits SMS and email links

Look at when the "no gesture" case happens:

- The person taps a link in **Google Messages, Samsung Messages or an email app**.
- Your App Links **aren't verified** for the link's domain on that phone, so Android passes the URL to the default browser.
- The default browser is **Samsung Internet**, which it often is on Galaxy phones.

If any one of those is false, the problem goes away. With verified App Links, Android opens the app before any browser runs. In Chrome, the hand-off opened the app in our runs. If the person is already in the browser and taps a link on a page, that tap is a user gesture.

So the issue is really "unverified App Links, made worse by a strict browser". Samsung Internet makes a verification gap that Chrome would hide easy to see.

## The fixes, in order

### 1. Verify your App Links

This is the real fix, and it helps every browser, not just Samsung's. With verification in place, a tapped link in Messages never reaches a browser at all.

The usual reasons verification fails:

- The SHA-256 fingerprint of the **Play App Signing** key is missing. If Google Play signs your app, the fingerprint of your local upload key isn't the one on users' phones.
- The intent filter lacks `android:autoVerify="true"`, or lists a different host from the one in your links.
- `assetlinks.json` is served with a redirect or the wrong content type.
- The app was installed before the fingerprints were published. Android checks at install time and sometimes again later, so reinstall to test.

Paste your link domain into the free [assetlinks.json checker](https://straitlink.in/tools/assetlinks-checker/) to see exactly what Android will read. The [SHA-256 mistakes post](https://straitlink.in/blog/android-app-links-verification-sha-256-mistakes/) covers each failure in detail. On Strait, you save your fingerprints in the dashboard and we serve the file on your link domain. See [App Links & Universal Links](https://straitlink.in/docs/app-links/).

### 2. Check Samsung Internet's own setting

Samsung Internet has a setting, **Settings → Useful features → Open links in other apps**, that controls whether it hands links to installed apps. When it's off, links stay in the browser. You can't change it for your users, but it's the first thing to check on a test phone that behaves oddly. Our [Android testing guide](https://straitlink.in/docs/sdks/android/test/) lists it with the other browser quirks.

### 3. Give the browser a real tap when there's no gesture

When a request reaches the link server without a gesture, the browser may refuse an automatic hand-off, but it will honour a tap on a button. Browsers tell you whether a navigation came from a user action with the `Sec-Fetch-User` request header. MDN describes it as sent, with the value `?1`, for "requests initiated by user activation", and left out otherwise ([MDN: Sec-Fetch-User](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Sec-Fetch-User)). A link server can use that signal to serve a small page with one **Open in app** button, which works because the tap on it is a gesture. Requests with the signal can keep getting the plain redirect.

To be clear about where Strait stands: today our engine answers Samsung Internet the same way as Chrome, with the intent hand-off, and we show a one-tap page only for in-app browsers such as Instagram and WhatsApp. A one-tap page for gesture-less Samsung Internet requests is on our list. It hasn't shipped, so fixes 1 and 2 are the ones to rely on now.

### 4. Choose the fallback on purpose

The `S.browser_fallback_url` decides what a refused hand-off looks like. Sending people to Google Play is right for people without the app, and it carries the link through a new install. For people who have the app, a Play page with an **Open** button is a detour, but it isn't a dead end. On Strait, the workspace setting **When someone without the app taps a link** chooses Play or your website as that fallback, so you can pick the lesser evil for your audience.

## How to test it yourself

- Install your release build, from Play if you can. Fingerprints for a sideloaded debug build differ from Play's.
- Set Samsung Internet as the default browser.
- Send yourself the link by SMS and tap it in the messaging app. That's the gesture-less path.
- Then open a web page in Samsung Internet that contains the link and tap it there. That's the gesture path.
- Repeat in Chrome to compare.

The free [Will it open?](https://straitlink.in/tools/will-it-open/) tool runs the same decision code as our engine and shows, for a browser and a link, what the server would answer: the intent URL, the fallback and why.

## Sources and how we checked

- Google, [Android Intents with Chrome](https://developer.chrome.com/docs/android/intents): the intent URL syntax, `S.browser_fallback_url`, and the cases where Chrome won't launch an app (no user gesture, a redirect from a typed URL, a JavaScript timer). Read on 5 October 2026.
- Android Developers, [App Links](https://developer.android.com/training/app-links): verified links open the app without a browser.
- MDN, [Sec-Fetch-User](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Sec-Fetch-User): sent as `?1` only for navigations initiated by user activation.
- Our real-phone runs on an Android 16 phone: the scripted suite (`scripts/analytics-test.sh` in our sample app's repository) that taps a link inside Samsung Internet and asserts the tap and the joined app open, and our recorded browser test from 3 October 2026 in which Samsung Internet 30, opened from outside the browser, used the Play fallback while the app was installed.
- The intent URL shape and fallback behaviour come from our engine's code and its unit tests.
