Deep Linking Explained: Universal Links vs App Links vs Deferred
A plain-English guide to mobile deep linking: 4 link types compared, 8 famous implementations (Airbnb, Pinterest, Spotify), iOS vs Android setup, and how to ship deep links without writing code.
A deep link is a URL that opens a specific screen inside your mobile app instead of dropping users on the home screen. Tap a Pinterest pin in someone’s Instagram bio and you land on that specific pin in the Pinterest app, not the Pinterest home feed. Tap a Spotify playlist link in iMessage and you arrive at that playlist, not the Spotify launcher. Done right, deep links cut user friction from “search the app for what I want” to “tap once and arrive.” This guide explains the 4 main deep link types (custom URI scheme, Universal Links, App Links, Deferred), 8 famous implementations, and how to ship them without writing code. For broader context, our API integration guide and cross-platform guide cover related foundations.
What You Will Learn
- Plain-English definition of deep linking
- 4 link types (URI scheme, Universal, App Links, Deferred)
- 8 famous deep link implementations
- iOS vs Android setup compared
- How to add deep links without writing code
- 8 deep linking mistakes that send users to crash screens
Backed by Apple Universal Links documentation, Android App Links setup guide, Branch Metrics Deep Linking Report 2026, AppsFlyer attribution data, and platform data from 10 million+ apps built on Appy Pie AI. Rated 4.7/5 on G2 from 1,388 reviews.
Build Your App With Deep Links Built InTL;DR Quick Summary
Deep linking is a URL-based mechanism that opens a specific screen inside a mobile app instead of the home screen. Four main types exist: custom URI schemes (legacy, e.g. spotify://), Universal Links (iOS standard since iOS 9), App Links (Android equivalent since Android 6), and Deferred deep linking (handles the case where the app is not yet installed). Apps with proper deep linking see 3-5x higher conversion from external clicks: Pinterest’s deep link campaigns drive 2x signup completion, Spotify’s playlist sharing converts 4x better than home-page redirects. Use Universal Links + App Links for normal cases; add Deferred when running install campaigns where users may need to download first.
Table of Contents
Jump to any section. This guide defines what deep linking is, walks through the 4 main types (URI scheme, Universal Links, App Links, Deferred), shows 8 famous implementations, compares iOS vs Android setup, breaks down build vs SaaS vs no-code choices, walks through how to add deep links without coding, and ends with the 8 mistakes that send users to crash screens or home pages.
- What is Deep Linking? (Plain Definition)
- Why Deep Links Drive 3-5x Conversion
- 4 Deep Link Types Compared
- 8 Famous Deep Link Implementations
- iOS Universal Links vs Android App Links
- Deferred Deep Linking Explained
- How to Add Deep Links Without Coding
- 8 Deep Linking Mistakes That Break Routing
- Frequently Asked Questions
- Conclusion
What is Deep Linking? (Plain Definition)
Deep linking is a URL-based mechanism that opens a specific destination inside a mobile app instead of just launching the app to its home screen. When a user taps a deep link from an email, a message, a social post, an ad, or a search result, the operating system recognizes the URL as belonging to your app and routes the user directly to the relevant screen with the right data already loaded.
The simplest way to picture it: a deep link is to mobile apps what an anchor link (#section-id) is to web pages. A web URL like https://example.com/products/42 takes you to a specific product page on the web. A deep link like https://example.com/products/42 can ALSO open the same page directly in the mobile app if the app is installed and configured to handle that URL. Same URL, two surfaces, contextual routing.
Three core pieces of every deep link
1. The URL itself. A standard HTTPS URL (preferred in 2026) or a legacy custom scheme (spotify://, fb://). The URL contains the routing information the app needs to know which screen to open and what data to display.
2. The OS-level association. A configuration that tells the operating system “URLs matching this pattern belong to this app.” On iOS this is the Associated Domains entitlement plus the apple-app-site-association file hosted on your web domain. On Android it is the assetlinks.json file plus intent filters in the manifest.
3. The in-app router. Code inside your app that parses the URL when it opens the app, determines which screen to show, and loads the right data. Most apps use a single deep link handler that maps URL patterns to screen routes (similar to a web router).
Four scenarios deep links handle
- App is installed and open: Tap link, app jumps to specified screen instantly.
- App is installed but not open: Tap link, app launches and opens specified screen.
- App is installed but on a different account: Tap link, app prompts to switch accounts or shows the linked content if accessible.
- App is NOT installed: Tap link goes to web version OR to app store with a “deferred” deep link that opens the right screen after the user installs and launches the app.
Deep links are NOT
- App store links. A link to your App Store or Play Store listing is just a download link, not a deep link.
- Browser intent links. Some web URLs open the browser even when the app is installed; that is broken deep linking, not the goal.
- QR codes. A QR code is a delivery mechanism; the URL inside the QR code is what may or may not be a deep link.
- Push notification routing. Push notifications can open specific screens but use a separate mechanism (notification payload), not URL routing.
Done right, deep linking is invisible. Users tap a link, the right screen appears with the right content, and they continue their task. Done wrong, deep linking is the most common reason users abandon apps they would otherwise want to use.
Why Deep Links Drive 3-5x Conversion
The data on deep linking is striking. Apps that route external clicks correctly see substantially better conversion than apps that drop everyone on the home screen. The challenge is that most teams set up deep linking once at launch and assume it works forever.
Three ways deep links move the business
1. Higher conversion from external touchpoints. An email campaign that links to “view your order” works dramatically better when the link opens the user’s order detail in the app vs dropping them on the home screen to navigate manually. Conversion lifts of 3-5x are typical for transactional flows.
2. Better marketing attribution. Deep links can carry campaign parameters (UTM, custom IDs) that survive into the app. You can attribute installs and in-app conversions back to specific campaigns, channels, and creatives. Without deep linking, this attribution is mostly impossible.
3. Smoother user-to-user sharing. When users share content from your app (a playlist, a product, a post, a profile), recipients who tap the shared link land directly in the app on the shared content. No “open this in the app and search for it” friction. Pinterest, Spotify, Airbnb, TikTok all rely on this.
What deep links do NOT solve
Deep linking is a routing technology, not a marketing solution. The content the deep link routes to still has to be useful. A deep link to a broken or empty screen is worse than no deep link at all because users blame the app. The full equation: deep link + valuable destination + minimal friction = high conversion. Skip any of those three and conversion collapses regardless of deep link quality.
The other thing deep linking does not solve: users who do not have the app installed. That is what Deferred Deep Linking is for, covered later in this guide.
4 Deep Link Types Compared
Four main types of deep links cover all mobile use cases in 2026. Each has different setup complexity, OS support, and behavior when the app is not installed.
1. Custom URI Scheme (Legacy)
Uses a custom protocol like myapp:// instead of HTTPS. The app registers the scheme with the OS. Tapping a custom scheme URL opens the app directly. Was the dominant approach a decade ago; now considered legacy but still functional.
spotify://playlist/37i9dQZF1DXcBWIGoYBM5M2. Universal Links (iOS)
HTTPS URLs that open your app instead of Safari. Configured via the Associated Domains entitlement plus an apple-app-site-association file hosted at https://yourdomain.com/.well-known/apple-app-site-association. The standard for iOS deep linking since iOS 9.
https://www.airbnb.com/rooms/123456783. App Links (Android)
HTTPS URLs that open your Android app instead of Chrome. Configured via intent filters in AndroidManifest.xml plus an assetlinks.json file hosted at https://yourdomain.com/.well-known/assetlinks.json. The Android equivalent of Universal Links.
https://www.pinterest.com/pin/1234567894. Deferred Deep Links
Handle the case where the app is not yet installed. User taps link, goes to app store, downloads app, and on first launch the app receives the original deep link context and opens the right screen. Requires a third-party service (Branch, AppsFlyer, Adjust) or custom implementation with fingerprinting.
Quick type decision matrix
Building a new app in 2026: Use Universal Links (iOS) + App Links (Android) as your default. They are the modern standard.
Need to handle app-not-installed flow: Layer Deferred deep linking on top of Universal/App Links via Branch, AppsFlyer, or Adjust.
Supporting legacy clients or specific use cases: Custom URI schemes still work as fallback. Spotify, Slack, and Discord all maintain custom schemes alongside Universal/App Links for backward compatibility.
Maintaining an old app: Migrate from custom URI schemes to Universal/App Links when next refactoring; the modern approach has better security and falls back to web gracefully.
What about iOS Smart App Banners and Android Instant Apps?
These are related but distinct concepts. Smart App Banners (iOS Safari) suggest installing your app when users visit your website in Safari. Android Instant Apps lets users run a portion of your app without installing. Both can be combined with Universal Links and App Links, but they are separate features, not deep link types.
8 Famous Deep Link Implementations
Eight well-known apps with documented deep linking strategies. Each shows a different aspect of how deep links drive engagement and growth.
Airbnb
Spotify
spotify:// custom scheme for backward compatibility plus modern Universal Links and App Links. Playlist sharing converts 4x better than dropping users on the home page.Netflix
YouTube
?t=42) jump to specific moments. The “open in YouTube” flow is so seamless users do not realize they crossed from browser to app.TikTok
Uber
Amazon
The common thread: every successful deep link implementation makes the path from “external touchpoint” to “value inside the app” as short as possible. Tap once, arrive. No “open the app, search, find” friction. The technology behind it is mature; the discipline is in maintaining the routing as your app grows.
iOS Universal Links vs Android App Links
Both platforms support modern deep linking but with different setup requirements, file formats, and reliability characteristics. Here is the comparison.
| Requirement | iOS Universal Links | Android App Links |
|---|---|---|
| Minimum OS version | iOS 9+ | Android 6+ |
| Configuration file name | apple-app-site-association | assetlinks.json |
| File hosting location | /.well-known/ or root | /.well-known/ only |
| Content-Type header | application/json | application/json |
| HTTPS required | Yes | Yes |
| App entitlement / manifest | Associated Domains entitlement | Intent filter in manifest |
| Multiple apps per domain | Yes | Yes |
| User can disable per app | Yes (Settings) | Yes (System defaults) |
| Long-press to open in browser | Yes (Safari) | Yes (Chrome) |
| Cache duration of config file | Can be cached aggressively | Verified on app install/update |
| Failure mode | Opens in Safari | Opens in Chrome / “Open with” dialog |
The iOS apple-app-site-association file
A JSON file describing which URL paths your app should handle. Hosted at https://yourdomain.com/.well-known/apple-app-site-association (no extension). Must be served as application/json over HTTPS. iOS downloads and caches this file when your app is installed and re-validates periodically.
{
"applinks": {
"details": [{
"appID": "ABCDE12345.com.yourcompany.yourapp",
"paths": ["/product/*", "/category/*", "/checkout"]
}]
}
}The Android assetlinks.json file
A JSON file linking your web domain to your Android app via SHA-256 fingerprints. Hosted at https://yourdomain.com/.well-known/assetlinks.json. Android Package Manager validates this file when your app is installed or updated.
[{
"relation": ["delegate_permission/common.handle_all_urls"],
"target": {
"namespace": "android_app",
"package_name": "com.yourcompany.yourapp",
"sha256_cert_fingerprints": ["XX:XX:XX:..."]
}
}]The cross-platform pattern that works
Most modern apps use a single URL structure that works on both platforms. The same URL https://example.com/product/123 opens iOS via Universal Links and Android via App Links. Both platforms route the URL to the appropriate native app; if the app is not installed, both fall back to the web version. Maintain ONE set of URL patterns; both OS-level mechanisms handle the routing.
Deferred Deep Linking Explained
Deferred deep linking handles the most valuable but most complex case: a user clicks a deep link, does NOT have your app installed, downloads it from the app store, and on first launch arrives at the screen the original link intended. The deep link “defers” its routing until after the app is installed.
The deferred flow step by step
- User taps a deep link in email, social, or web (e.g. “Check out this pin”).
- The deep link service (Branch, AppsFlyer, Adjust) detects the user does not have the app installed.
- The user is redirected to the App Store or Play Store to download the app.
- The service stores the original link context server-side, identified by a fingerprint of the user’s device (IP, user agent, screen size).
- The user downloads and launches the app for the first time.
- On first launch, the app’s SDK queries the deep link service with the device fingerprint.
- The service returns the original link context (e.g. “this user wanted to see pin #123”).
- The app routes to the relevant screen (the pin page), bypassing the home screen and any standard onboarding flow.
Why deferred deep linking matters
Without it, install campaigns lose the marketing context the moment the user enters the app store. A user clicks an ad for “this specific product on Amazon,” installs Amazon, and lands on the generic home screen. The product they came to see is now buried 4 taps deep. Conversion crashes.
With deferred deep linking, the same user installs the app and lands directly on the product page. The marketing context survives the install. Attribution tracks back to the original campaign. Conversion stays high.
Services that provide deferred deep linking
- Branch (now part of Foursquare). Most widely used. Free tier covers many small apps. Strong attribution features.
- AppsFlyer. Enterprise-focused. Strong fraud detection and ad network integration. Paid only.
- Adjust. European-strong. GDPR-first. Paid only.
- Firebase Dynamic Links. Google’s deferred deep linking service. Was free, now being deprecated (sunsetting in 2026-2026).
For most apps, Branch is the default choice. Custom-built deferred deep linking is technically possible but requires server-side fingerprinting and ongoing maintenance that almost nobody does well.
What deferred deep links cannot do
Privacy regulations (iOS 14.5+ App Tracking Transparency, EU GDPR) limit the fingerprinting techniques deferred deep linking depends on. Match rates have dropped from ~95% pre-2021 to ~75-85% in 2026. Some campaigns now use clipboard-based passing (Branch’s “Universal Object” approach) which is more reliable but requires explicit user gestures.
The takeaway: deferred deep linking is still essential for install campaigns but is less magical than it was 5 years ago. Plan for 15-25% of installs to lose context.
How to Add Deep Links Without Coding
For custom-coded apps, adding deep linking requires the Associated Domains entitlement on iOS, intent filters on Android, hosting the apple-app-site-association and assetlinks.json files, implementing in-app routing, and integrating Branch or similar for deferred. That is 2-4 weeks of engineering for a basic implementation. No-code platforms expose deep linking as a feature module with all of this pre-built. Here is the flow on the Appy Pie AI App Generator.
Open the AI App Generator and describe what your app does. The platform scaffolds a project with deep linking infrastructure pre-configured: Universal Links on iOS, App Links on Android, plus an in-app router that maps URLs to screens automatically based on your app’s structure.
The AI confirms it has enough context. Based on your app’s structure, it generates a default URL pattern for each screen. Product pages become /product/{id}; user profiles become /user/{handle}; categories become /category/{slug}. You can override any pattern in settings.
For each screen, toggle “deep linkable” on or off. Most user-facing screens should have deep links (product, profile, category). Internal screens (settings, admin) usually do not. The platform handles the URL routing and apple-app-site-association/assetlinks.json file generation automatically.
For install-driven marketing, enable deferred deep linking. The platform integrates Branch SDK automatically and configures the post-install routing. Your install ads now route users to the correct screen on first launch instead of dropping them on the home screen.
The platform generates shareable URLs for every screen in your app. Tap a URL on your phone; it opens the app on that screen. The platform also handles the apple-app-site-association and assetlinks.json hosting automatically on its domain or your custom domain. Publish to iOS, Android, and PWA when ready.
What used to be 2-4 weeks of platform-specific setup (entitlements, manifest config, hosted JSON files, in-app router code, Branch integration, post-install handling) is now a few configuration screens. The platform handles every cross-platform difference and every required hosted file. You focus on which URLs map to which screens; the platform handles the rest.
8 Deep Linking Mistakes That Break Routing
The deep linking mistakes we see most often, drawn from analyzing thousands of apps on the Appy Pie AI platform plus the Branch Metrics 2026 Deep Linking Report. Each has a clear fix.
Missing or stale apple-app-site-association file
The file is hosted at launch but a CDN config change or domain migration breaks it 6 months later. Every iOS deep link silently fails. Nobody notices until users complain.
Wrong Content-Type on the config file
File serves with Content-Type text/html or application/octet-stream instead of application/json. iOS rejects it; Universal Links fail silently.
application/json. Verify with curl -I the URL and check the Content-Type header.Wrong SHA-256 fingerprint in assetlinks.json
Android assetlinks.json contains the fingerprint of your debug signing certificate instead of release. Deep links work in development; fail in production.
keytool -list -v -keystore release.keystore. Include both debug and release fingerprints if you need deep links in both.Deep link routes to wrong screen on auth flow
User taps deep link to “view your order #42” but is logged out. Instead of showing login then routing to order #42 after, the app drops to home screen after login. Original intent is lost.
Custom URI scheme as the primary mechanism
Using myapp:// instead of HTTPS Universal/App Links. When the app is not installed, the URL fails to open anything; users see a “Cannot find page” error.
No fallback to web when app is not installed
Universal Link logic assumes the app is installed. When it is not, the link does nothing visible to the user. The intended content is never seen.
Not preserving query parameters across the route
URL contains ?utm_source=email&campaign=summer. Deep link routes user to product page but the in-app analytics never sees the UTM parameters. Attribution is lost.
No version handling for old links
You release v2.0 with new URL structure. Users still share v1.0 URLs from old screenshots, social posts, emails. The v1.0 URLs no longer route correctly in v2.0.
Deep Links Configured. Routing Works. Zero Code.
Appy Pie AI App Generator configures Universal Links on iOS, App Links on Android, hosts the required apple-app-site-association and assetlinks.json files, integrates deferred deep linking, and gives you a visual editor for URL patterns. Skip 4 weeks of platform-specific setup.
Try AI App Generator App BuilderFrequently Asked Questions About Deep Linking
What is deep linking in simple terms?
Deep linking is a URL-based mechanism that opens a specific screen inside a mobile app instead of just launching the app to its home screen. When users tap a deep link from email, social, ads, or search, they land directly on the relevant content with the right data already loaded. Modern deep links use HTTPS URLs that work seamlessly between web and app.
What is the difference between Universal Links and App Links?
Universal Links are Apple’s deep linking mechanism for iOS (since iOS 9). App Links are Google’s equivalent for Android (since Android 6). Both use HTTPS URLs and a hosted JSON file (apple-app-site-association for iOS, assetlinks.json for Android) that proves your app should handle URLs from your web domain. The mechanisms are different but the user experience is identical.
What is deferred deep linking?
Deferred deep linking handles the case where the user does not have your app installed yet. User clicks a deep link, gets sent to the app store to download the app, and on first launch the app shows the original link’s intended screen. Services like Branch, AppsFlyer, and Adjust provide this functionality. Essential for install-driven marketing campaigns.
Do I need a third-party service for deep linking?
For standard deep linking (user has app installed), you can implement Universal Links and App Links entirely with platform-native tools, no third-party service needed. For deferred deep linking (user does not have app yet), you typically need a service like Branch unless you want to implement your own server-side fingerprinting (rarely worth the effort).
How do I test deep links during development?
On iOS, use xcrun simctl openurl booted "https://yourdomain.com/path" in the simulator. On Android, use adb shell am start -W -a android.intent.action.VIEW -d "https://yourdomain.com/path". Both also work on real devices via the simulator/emulator. Tools like Branch’s link tester help validate Universal/App Link configurations end-to-end.
Why do my deep links work in development but fail in production?
Three common causes: (1) Wrong SHA-256 fingerprint in assetlinks.json (debug cert vs release cert). (2) Production server not serving the apple-app-site-association file with Content-Type application/json. (3) Production app entitlements not matching development. Verify each with the actual production URLs.
Can users disable deep linking for my app?
Yes, on both platforms. iOS users can disable Universal Links for a specific app in Settings → [App Name] → Off. Android users can change default behavior in System defaults → Open by default. When disabled, taps to your domain open in Safari/Chrome instead of your app. There is no way to force this.
How much does deep linking cost to implement?
For a custom-coded app: 2-4 weeks of engineering ($10K-$40K) plus Branch Metrics subscription if you need deferred deep linking ($0-$2,000/month based on volume). No-code platforms like Appy Pie AI include deep linking as a feature module with no additional cost beyond the platform subscription.
What is the difference between custom URI schemes and Universal Links?
Custom URI schemes use a non-standard protocol like myapp://. They open the app if installed but fail if not (with a confusing error). Universal Links use standard HTTPS URLs that open the app if installed and fall back to the web version if not. Universal Links are the modern standard; custom URI schemes are legacy.
Can deep links carry parameters?
Yes. URLs can include path segments (/product/42) and query strings (?utm_source=email&ref=summer). Your deep link handler extracts these parameters and passes them to the destination screen. UTM parameters for marketing attribution, IDs for content routing, and feature flags all work through query strings.
Why do 18% of deep links fail?
According to Branch Metrics’ 2026 Deep Linking Report, the most common failure causes are stale configuration files (apple-app-site-association or assetlinks.json missing or misconfigured), wrong Content-Type headers, expired or mismatched fingerprints, and apps not handling new URL patterns added after launch. Most failures are infrastructure issues, not code bugs.
Should I migrate from custom URI schemes to Universal Links?
Yes, when you can. Universal Links provide better security (verified domain ownership), better fallback (works if app is not installed), and better user experience (no “this URL cannot be opened” errors). Most apps migrate during a major refactor. Keep custom URI schemes as fallback for backward compatibility with old shared links.
Deep Links Are Routing Infrastructure, Not Magic.
The fundamentals are simple. Use Universal Links on iOS and App Links on Android as your primary mechanism. Host the apple-app-site-association and assetlinks.json files on your web domain with the correct Content-Type. Layer deferred deep linking on top via Branch when running install campaigns. Preserve query parameters across routes for attribution. Monitor the configuration files monthly because they break silently and cost you 18% of deep link clicks when they do. Maintain backward compatibility for old URL patterns; shared links live in the wild for years. Build smarter with our complete app creation guide or check our API integration guide for the broader picture of services your deep-linked app depends on.
Build Your App With Deep Links →Deep Links Handled. You Build the App.
Appy Pie AI App Generator configures Universal Links, App Links, deferred deep linking, and hosts the required JSON files automatically. Skip 4 weeks of platform-specific setup and ship deep links that work on day one.
Build My App With AI4.7/5 on G2 with 1,388 reviews | 10M+ apps built since 2016