Deep Link: What It Is, Types of Links, and How It Works

What Is a Deep Link

A Deep Link is a URI that opens not a web page but a specific screen inside a mobile application when clicked. The technology solves a fundamental problem of mobile platforms: the browser cannot directly open an app screen, and a deep link creates a bridge between the web and native code. Without a deep link, the user always lands on the home screen and must manually navigate to the desired content.

The architecture of a deep link consists of two parts: the scheme defines which app should handle the link, and the path points to a specific resource inside the app — a product, article, user profile, or settings section. Query parameters (?source=push&campaign=summer) pass additional context for analytics, personalization, and campaign attribution.

It is important to distinguish between a deep link and a regular link. A regular link (https://example.com/product/42) opens in the browser and leads to the web version of a page. A deep link (myapp://product/42), if the app is installed, opens the native screen with the same content, but if the app is not installed, it shows an error. Universal Link (iOS) and App Link (Android) were created precisely to solve the problem of seamless fallback.

Types of Deep Links

Different tasks require different types of deep links. Some links work only with the installed app, others can wait for installation, and still others pass analytical context. The choice of type depends on the use case: advertising campaign, push notification, content sharing, or email newsletter.

Standard Deep Link

A Standard Deep Link is the basic type that triggers only if the app is already installed on the device. The user clicks a link myapp://product/42, the system detects the registered scheme and opens the app on the desired screen. If the app is not installed, the browser shows an error “Page Not Found” or simply does nothing. This type is suitable for internal navigation within an already installed application.

Setting up a standard deep link is simple: just register the URI scheme in the manifest (Android) or Info.plist (iOS). No server validation or SSL certificates are required. However, precisely because of the lack of fallback, this type is considered outdated for marketing campaigns — traffic loss from users without the app can reach up to 60%.

Deferred Deep Link

A Deferred Deep Link solves the main problem of regular deep links: it works even if the app is not installed. The user clicks a link → sees a page (landing or App Store/Google Play) → installs the app → on first launch, the app receives the context of the original link and opens the desired screen. The technology requires an intermediary SDK (AppsFlyer, Branch, Adjust) that stores the context on the server until the first launch.

Branch is one of the most popular platforms for deferred deep links. It provides a single link that works on all platforms: it detects the user's OS, redirects to the app store, and after installation passes the context (promo code, product ID, campaign source). According to Branch (2024), deferred deep links increase advertising campaign conversion by 40–70%.

Contextual Deep Link

A Contextual Deep Link is a regular or deferred deep link supplemented with context parameters: traffic source, campaign, promo code, referrer, partner ID. The parameters are passed in the URL and processed by the app for personalization: show a welcome bonus, open a discounted product, record installation analytics.

UTM tags (utm_source, utm_medium, utm_campaign) are a standard way to pass context. In mobile, contextual deep links are critical for attribution: without them, the app owner does not know which channel brought the user — organic traffic, Facebook ads, email newsletter, or QR code. Quality attribution requires integration with an MMP (Mobile Measurement Partner).

Deep Link on iOS

iOS supports deep links through two mechanisms: the older Custom URL Scheme and the modern Universal Link (iOS 9+). Custom URL Scheme works by registering a custom scheme in Info.plist. The app registers myapp://, and iOS opens the app when such a link is clicked. The problem: if the scheme is not registered by any app, the browser shows an error.

Handling deep links on iOS occurs through the AppDelegate method application(_:open:options:) or SceneDelegate scene(_:openURLContexts:). The developer extracts the URL, parses the path and parameters, then navigates to the appropriate screen. If SwiftUI is used, handling is done through OpenURLAction or onChange(of: openURL). It is important to correctly handle the app state: the app may be not launched, backgrounded, or active.

Security on iOS is strict: any app can intercept a Custom URL Scheme by registering the same scheme. This is a potential vulnerability (URL Scheme hijacking). Therefore, Apple recommends Universal Link as a more secure alternative: only the verified domain owner can associate links with the app. Learn more about Universal Link in the article Universal Link.

Deep Link on Android

Android implements deep links through Intent Filters in AndroidManifest.xml. The app defines an Activity that handles a specific scheme (myapp://) or specific hosts and paths. When the user clicks a deep link, Android looks for an Activity with a matching Intent Filter and opens it. If there are multiple matching Activities, the system shows an app chooser dialog.

// AndroidManifest.xml - Intent Filter for Deep Link
<activity
    android:name=".ui.ProductActivity"
    android:exported="true">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data
            android:scheme="myapp"
            android:host="product"
            android:pathPrefix="/" />
    </intent-filter>
</activity>

Handling deep links on Android is done in the Activity.onCreate() or onNewIntent() method. The developer receives the Intent, extracts the URI, and triggers navigation. For Jetpack Navigation, the Navigation Deep Link component allows declaratively describing deep links in the navigation graph. Android App Link (Android 6.0+) is an evolution of deep links with verification through Digital Asset Links, eliminating the app chooser dialog.

It is important to consider Android 12+ changes: starting from API 31, the system requires explicit declaration of exported=true for Activities handling deep links and checks the correctness of the Intent Filter. Google Play Store verifies App Link verification during publishing. Without verification, Google may reject the update if deep links lead to non-existent website pages.

Deep Link Setup

Setting up deep links includes several stages common to both platforms. The first step is to define the scheme and URL structure. It is recommended to use the https scheme (instead of a custom one) for compatibility with Universal Link and App Link. The URL structure should mirror the website structure: /product/42, /profile/john, /settings/notifications. This simplifies maintenance and content indexing by search engines.

The second stage is handling deep links in the app code. For Android, Jetpack Navigation with declarative deep links in nav_graph is recommended. For iOS, SwiftUI NavigationStack with OpenURLAction handling. It is important to handle three app states: cold start (app not launched), warm start (backgrounded), and active (on screen). Each state requires different navigation logic.

• Define the scheme and URL structure (myapp:// or https://your.domain/)
• Register the scheme in the manifest (Android) or Info.plist (iOS)
• Implement handling in Activity or AppDelegate/SwiftUI
• Set up fallback for the case when the app is not installed
• Test all three states: cold start, warm start, active

Testing deep links is a separate task. Android Studio provides the App Links Assistant tool for checking Intent Filters. On iOS, testing is done through Xcode by passing a URL via launch scheme arguments. It is recommended to set up CI checks: automatic deep link navigation and verification that the expected screen opened. For deferred deep links, testing includes the full cycle of “installation → first launch → context.” Without testing, deep links often break when the app navigation is updated.