Mobile App URLs: Deep Linking Guide for iOS & Android

Mobile App URLs: Deep Linking Guide for iOS & Android

Mobile app URLs are just links that open a specific screen inside an app instead of a website. You've got a few ways to make this happen. You can use custom schemes like myapp://product/123, HTTPS Universal Links or App Links (like https://example.com/product/123 which rely on AASA or assetlinks.json files), or deferred deep links that somehow manage to carry that product/123 payload all the way through an app install.

Pick the wrong approach and you'll end up with broken redirects, lost attribution data, and users staring at a blank screen. Here's how these links actually work on iOS and Android, what you can do with parameters, and how to test them before you ship.

What a mobile app URL is

Flowchart illustrating mobile app URL deep linking process with iOS and Android verification methods

A mobile app URL is just a link that opens a specific screen inside an app rather than a regular website. It can use a custom scheme, a standard HTTPS domain, or a hybrid format depending on the platform.

The catch is that the operating system needs to know which app owns the link, and whether that app is even installed. Regular web links don't have this problem. That's why Apple and Google built verification systems: Apple uses an apple-app-site-association file, and Google uses assetlinks.json. If you don't have these files set up, the OS just falls back to treating your link as a standard web address.

When you break it down, a mobile app URL usually carries three things:

  • The scheme or domain (tells the OS which app to check)

  • The path (tells the app which screen to load)

  • Parameters (extra data like referral codes or campaign tags)

Honestly, maintaining all these verification files and fallback rules for every platform is a headache. Smler handles this routing logic automatically so you don't have to.

Linking an app to a website means setting up a shared trust relationship between a domain and an app's package, so one clickable URL opens your app directly or falls back to a browser page if the app isn't installed. It is not the same as putting a "Download our app" button on a webpage. Teams usually want one of two things: route existing web traffic into the app, or make app content shareable as a normal web URL. Both need the same setup: domain verification files, platform-specific configuration, and a routing layer that decides where each click lands.

Method

Works without install?

Best for

Native App Links / Universal Links

No

Returning users, retargeting

Deferred deep links

Yes

New user onboarding, referrals

Smart / device-based links

Yes

Cross-platform campaigns, QR codes

Most mature products use all three depending on the channel. Setup follows five steps on either platform:

  1. Verify a domain you control, ideally a custom branded domain rather than a shared shortener domain.

  2. Publish the association file: apple-app-site-association for iOS, assetlinks.json for Android, both served over HTTPS with no redirects.

  3. Configure the app: the associated domains entitlement in Xcode and the intent filters in your Android manifest.

  4. Test the handshake by visiting each file's URL to confirm the content is visible. Skipping this is the most common reason app links silently fail in production.

  5. Wrap the link in a trackable smart link so every click is tracked from day one.

Common mistakes:

  • Treating the website side and the app side as separate projects owned by different teams, which creates mismatched URLs and broken redirects.

  • Forgetting the fallback URL. Every app link needs a sensible web destination for users without the app.

  • Using unbranded or unverified domains for QR codes and SMS, which some carriers flag in compliance-sensitive campaigns.

  • Letting links rot after an app rebrand: package name or bundle ID changes break existing association files silently. Teams moving off Firebase Dynamic Links hit this constantly.

How these links behave depends entirely on whether the user actually has your app installed.

Custom schemes are the oldest format. They still technically work, but you can't click them directly from Safari or Chrome anymore because of security changes. Universal Links and App Links fix that by using standard HTTPS domains that the OS verifies against a hosted JSON file. Deferred deep links go one step further: they actually survive the app install process itself.

Type

Example URL

Opens app when installed

What happens when not installed

Verification file

Custom scheme

myapp://product/123

Yes, if OS resolves the scheme

Error or blank screen, no fallback

None required

iOS Universal Link

https://example.com/product/123

Yes, directly in-app

Redirects to App Store

apple-app-site-association

Android App Link

https://example.com/product/123

Yes, directly in-app

Redirects to Play Store

assetlinks.json

Deferred deep link

https://example.com/product/123?ref=sms

N/A, triggers install flow first

Redirects to App Store or Play Store, then resumes after open

Attribution SDK or Install Referrer

You'll notice the exact same URL format works for both Universal Links and Android App Links. That's not a typo. A single HTTPS link can work flawlessly across iOS and Android, provided you have both verification files hosted on that domain.

A minimalist dark-themed illustration showing cards with deep link URL examples, each card highlighting the path and query parameters in a structured format.

A deep link URL usually combines a path with at least one query parameter. The path tells the app what to draw on the screen, and the parameters just tag along to pass tracking or personalization data.

Here are a few realistic examples:

https://example.com/product/123?ref=email
The app opens the product detail screen for item 123 and logs the referral source as email.

https://example.com/checkout?cart_id=9f82a1&promo=WELCOME10
The app resumes a saved cart and auto-applies a promo code at checkout.

myapp://profile/4521?utm_source=instagram&utm_campaign=fall_launch
The app opens a user profile and attributes the visit to an Instagram campaign.

https://example.com/article/9981?lang=fr
The app renders the article screen in French based on the lang parameter.

https://example.com/invite?code=ABCDE12345
The app opens an invite acceptance screen and validates the referral code server-side.

This is exactly why a plain custom scheme isn't enough on its own. You need those parameters to carry campaign, language, and session context so the app actually renders the right experience. Smler's analytics layer grabs these parameters automatically, so marketers can see which path or campaign tag drove the click without building custom logging logic from scratch.

Deferred deep links are incredibly useful because they work even when the user doesn't have the app installed yet. The link routes them to the App Store or Play Store first, then passes the original path and parameters back to the app the first time they open it.

Say someone clicks https://example.com/product/123?ref=sms but doesn't have your app. Here's the flow:

  1. The OS checks for Universal Link or App Link support and finds nothing.

  2. The link falls back to a store redirect page.

  3. The user installs the app and opens it.

  4. The attribution SDK or Install Referrer API matches the fresh install to the original click.

  5. The app opens directly to product/123 instead of dumping them on the home screen.

This matching happens through Android's Install Referrer API or, on iOS, alternative mechanisms such as temporary clipboard-based attribution, as iOS does not provide an Install Referrer-style API. If you want a deeper technical breakdown of how this differs from a direct deep link, check out the deep linking vs deferred deep linking comparison. The actual implementation details are in the deferred deep links documentation.

Testing a mobile app URL on iOS and Android

Three cards illustrating mobile app URL testing processes: iOS testing with xcrun tool, Android testing with adb command, and verification file requirements, presented in dark background with blue accents

You really don't want to test mobile app URLs in production. Catching broken redirects, missing verification files, and parameter parsing bugs before launch will save you a lot of headaches. Apple and Google both provide command-line tools so you can simulate clicks without running a live campaign.

On iOS, you can use xcrun simctl openurl to fire a link directly into the simulator. On Android, adb shell am start does the exact same thing for emulators or connected devices. Just remember that both platforms require their respective verification files to be reachable and properly formatted before links will open the app at all.

A few platform differences matter while testing: iOS Universal Links fail silently if the association file isn't perfectly formatted, Chrome can sometimes show a disambiguation dialog for Android App Links, and both platforms cache verification results, so fixes take time to propagate. Before launch, open the link from a messaging app (not just a browser address bar), test with the app both installed and uninstalled, confirm the link preview renders when shared, and check the troubleshooting guide for platform-specific edge cases. Once links work, track install rate, time to first action and device-level conversion, not just clicks.

Rather than repeating every step here, I'll point you to two dedicated guides that cover the full process:

If you want to keep going down the rabbit hole:

Frequently asked questions

What is an example of a mobile app URL?

It could be a custom scheme like myapp://product/123, an HTTPS Universal Link or App Link like https://example.com/product/123, or a deferred deep link that carries that same path all the way through an app install.

What is the difference between a custom URL scheme and a Universal Link?

A custom scheme only works if the app is already installed, and it can't be opened safely from a browser. A Universal Link uses a real HTTPS domain, works fine in browsers, and falls back to a normal webpage if the app is missing.

Does a mobile app URL work if the app is not installed?

It depends. A custom scheme usually just fails silently. A Universal Link or App Link opens a normal webpage. A deferred deep link will redirect the user to the app store and resume the original destination after they install the app.

How do I test a mobile app URL?

You can use xcrun simctl openurl on an iOS simulator or adb shell am start on an Android emulator to simulate a click. Detailed steps are in the iOS and Android testing guides linked above.

Do I need a verification file for every mobile app URL?

Custom schemes don't need one. But Universal Links require an apple-app-site-association file, and App Links require an assetlinks.json file hosted on your domain.

Can one URL work as both a Universal Link and an App Link?

Yes. The same HTTPS URL (like https://example.com/product/123) works for both iOS and Android as long as both verification files are correctly configured on that domain.

What is the difference between an app link and a regular hyperlink?

A regular hyperlink always opens in a browser. An app link is verified against your app's package or bundle ID, so it can open directly inside the installed app instead.

Can I link a website to a mobile app without app store approval?

Yes. App linking configuration happens through domain verification files and app manifest settings, separate from the app store review process.

Why does my app link open the browser instead of the app?

This usually means the association file is missing, misformatted, or not served over HTTPS without redirects. Use a validator to check before assuming it's a code issue.