What Are Instant Apps and App Clips

Android Instant Apps and iOS App Clips let users experience a lightweight version of your app without installing it first. They load instantly from a URL, giving users immediate access to a specific feature or workflow.

For app developers focused on growth and App Store Optimization, instant experiences are a powerful acquisition channel. They lower the barrier to entry by removing the install step, letting users try before they commit. When done right, they drive higher conversion rates from discovery to full app install.

The foundation of both systems is the URL. Every instant experience starts with a user tapping a link, scanning a QR code, or interacting with an NFC tag. Your URL structure determines what the user sees, how the experience loads, and how effectively you can track and optimize the funnel.

Step 1: Plan Your URL Structure and Domain Strategy

Before writing any code, map out which parts of your app should be available as instant experiences. Not every screen needs one. Focus on high-value entry points that showcase your app’s core functionality.

Choosing What to Make Instant

Ask yourself:

Which features give users immediate value without account creation?
What are the most common entry points from search, social, or messaging?
Which workflows can run in under 15 MB (Instant Apps) or 15 MB (App Clips)?
What experiences naturally lead to a full app install?

Good candidates include product pages, restaurant menus, parking payment, event check-in, content previews, and trial experiences.

URL Path Design

Your URLs should be clean, descriptive, and organized:

https://example.com/menu/restaurant-name
https://example.com/parking/lot-id
https://example.com/event/event-slug/check-in
https://example.com/preview/content-id

Avoid query-parameter-heavy URLs for primary routing. Use path segments for the main navigation and reserve query parameters for tracking, personalization, and campaign attribution:

https://example.com/menu/joes-pizza?utm_source=qr&table=12

Subdomain vs Path-Based Routing

You have two options for organizing instant app URLs:

Path-based (recommended):

https://example.com/instant/feature-name
https://example.com/clip/feature-name

Subdomain-based:

https://instant.example.com/feature-name
https://clip.example.com/feature-name

Path-based routing is simpler to manage and keeps all SEO authority on your primary domain. Subdomain routing offers cleaner separation but requires additional DNS and certificate configuration.

Step 2: Configure Android App Links for Instant Apps

Android Instant Apps rely on Android App Links to verify that your app is authorized to handle URLs from your domain.

Host the Digital Asset Links File

Create a file at https://example.com/.well-known/assetlinks.json:

[
  {
    "relation": ["delegate_permission/common.handle_all_urls"],
    "target": {
      "namespace": "android_app",
      "package_name": "com.example.app",
      "sha256_cert_fingerprints": [
        "YOUR_APP_SIGNING_CERTIFICATE_SHA256"
      ]
    }
  }
]

This file must be served over HTTPS with content type application/json. It must be accessible without redirects.

Declare Intent Filters

In your AndroidManifest.xml, add intent filters for each URL pattern your Instant App handles:

<intent-filter android:autoVerify="true">
  <action android:name="android.intent.action.VIEW" />
  <category android:name="android.intent.category.DEFAULT" />
  <category android:name="android.intent.category.BROWSABLE" />
  <data
    android:scheme="https"
    android:host="example.com"
    android:pathPrefix="/menu" />
</intent-filter>

The android:autoVerify="true" attribute tells the system to verify domain ownership at install time. For Instant Apps, this verification happens when the URL is first accessed.

Instant App Module Configuration

Structure your Instant App as feature modules, each mapped to specific URL patterns:

app/
  base/          - shared code and resources
  feature-menu/  - handles /menu/* URLs
  feature-parking/ - handles /parking/* URLs

Each feature module should be under the 15 MB size limit. Use the Android App Bundle format and let Google Play handle dynamic delivery.

Step 3: Configure Universal Links for iOS App Clips

iOS App Clips use Universal Links through the apple-app-site-association (AASA) file to connect URLs to your App Clip experience.

Host the AASA File

Create or update the file at https://example.com/.well-known/apple-app-site-association:

{
  "appclips": {
    "apps": [
      "TEAM_ID.com.example.app.Clip"
    ]
  },
  "applinks": {
    "apps": [],
    "details": [
      {
        "appIDs": [
          "TEAM_ID.com.example.app",
          "TEAM_ID.com.example.app.Clip"
        ],
        "components": [
          { "/": "/menu/*", "comment": "Restaurant menu pages" },
          { "/": "/parking/*", "comment": "Parking payment" }
        ]
      }
    ]
  }
}

The appclips section is specific to App Clips. The applinks section handles Universal Links for both the full app and the App Clip.

App Clip URL Patterns

App Clips support up to 500 registered URL patterns per app. Each pattern is registered in App Store Connect under your App Clip’s configuration.

When registering URL patterns, you can use:

Exact paths: https://example.com/menu/joes-pizza
Prefix matching: https://example.com/menu/*
Query parameter handling: The App Clip receives the full URL including query parameters

App Clip Size Constraints

App Clips must be under 15 MB uncompressed. This constraint forces you to keep the experience focused and fast-loading. Strip out any code, assets, or frameworks that are not essential to the specific URL-triggered experience.

Step 4: Implement Deep Link Routing in Your App Code

Both platforms deliver the triggering URL to your app code. You need a routing layer that maps URLs to screens.

Android Routing

// In your Instant App activity
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    val uri = intent.data ?: return

    when {
        uri.path?.startsWith("/menu") == true -> {
            val restaurantId = uri.lastPathSegment
            navigateToMenu(restaurantId)
        }
        uri.path?.startsWith("/parking") == true -> {
            val lotId = uri.lastPathSegment
            navigateToParking(lotId)
        }
        else -> navigateToHome()
    }
}

iOS Routing

// In your App Clip's SceneDelegate or App struct
func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
    guard let url = userActivity.webpageURL else { return }
    let path = url.pathComponents

    switch path.first {
    case "menu":
        let restaurantId = path.last ?? ""
        navigateToMenu(restaurantId: restaurantId)
    case "parking":
        let lotId = path.last ?? ""
        navigateToParking(lotId: lotId)
    default:
        navigateToHome()
    }
}

Handling Query Parameters

Parse query parameters for campaign tracking and personalization:

https://example.com/menu/joes-pizza?source=qr&table=12&promo=WELCOME10

Extract source for analytics attribution, table for contextual personalization, and promo for promotional pricing. Pass these through to your analytics and conversion tracking pipeline.

Step 5: Verify Domain Ownership on Both Platforms

Domain verification proves to each platform that you own the URLs your app claims to handle.

Android Verification

Ensure your assetlinks.json is accessible at https://yourdomain.com/.well-known/assetlinks.json
The certificate fingerprint must match your app’s signing key
Use the Statement List Generator to validate your file
In Google Play Console, navigate to your app’s deep linking settings and verify the domain

iOS Verification

Ensure your apple-app-site-association file is at https://yourdomain.com/.well-known/apple-app-site-association
The file must be served as application/json with no redirects
Your App ID in the AASA file must match your provisioning profile
In Apple Developer portal, add the Associated Domains capability to both your full app and App Clip targets
Add the appclips entitlement: com.apple.developer.associated-appclip-app

Debugging Verification

Android: Use adb shell am start to test URL handling locally. Check the Digital Asset Links API for remote verification status.

iOS: Use Apple’s AASA validation tool or swcutil on macOS to debug association file issues. The CDN caches AASA files, so changes can take up to 24 hours to propagate.

Step 6: Set Up Invocation Points

Invocation points are the places where users encounter and launch your instant experience.

QR Codes and NFC Tags

Generate QR codes and program NFC tags with your verified URLs. These work for both Instant Apps and App Clips. Place them at physical locations relevant to your app’s functionality: restaurant tables, parking meters, event venues, retail displays.

Safari App Clip Banners (iOS)

Add the Smart App Banner meta tag to your website pages to prompt App Clip launches in Safari:

<meta name="apple-itunes-app"
  content="app-clip-bundle-id=TEAM_ID.com.example.app.Clip,
           app-id=YOUR_APP_STORE_ID">

This shows a banner at the top of Safari when users visit your URL on iOS, offering to launch the App Clip experience.

Google Search and Maps (Android)

Instant Apps can surface directly in Google Search results and Google Maps listings. When a user taps an eligible result, the Instant App loads without requiring installation. Ensure your URLs are indexed by Google and your structured data markup is in place.

App Store and Google Play Listings

Both platforms can display instant experience options on your app’s store listing. Users can try the app before installing. This directly impacts your conversion rate and is a meaningful ASO advantage since users who try your app are far more likely to install it.

Step 7: Test URL Handling

Thorough testing prevents broken user experiences. Test every URL pattern across multiple scenarios.

Test Matrix

Scenario	Expected behavior
URL on supported device, full app not installed	Instant experience loads
URL on supported device, full app installed	Full app opens to correct screen
URL on unsupported device	Website loads as fallback
URL with invalid path	Graceful error or home screen
URL with query parameters	Parameters parsed and applied
URL from QR code scan	Instant experience loads
URL from NFC tap	Instant experience loads
URL from messaging app	Instant experience or app opens

Platform-Specific Testing

Android: Use the instantapps ADB flag to simulate Instant App behavior. Test on multiple API levels (API 26+ for Instant Apps).

iOS: Use the _XCAppClipURL environment variable in Xcode to test App Clip URL handling. Test on iOS 14+ for App Clips.

Step 8: Monitor Performance and Optimize

After launch, track how your instant experiences perform and iterate on the URL structure and user flow.

Key Metrics to Track

Invocation rate - how often each URL triggers an instant experience
Completion rate - how many users complete the key action in the instant experience
Install conversion - percentage of instant experience users who install the full app
Retention - do users who came through instant experiences retain better than other channels?
Deep linking success rate - percentage of URLs that resolve correctly to the intended screen

ASO Impact

Monitor how instant experiences affect your store listing performance:

Keyword rankings - instant experience engagement signals can influence rankings
Conversion rate - try-before-install reduces friction and increases the install rate
Category rankings - higher install velocity from instant experiences improves overall ranking
User ratings - users who tried the app before installing tend to leave better reviews

Use ASODOG to track changes in your keyword rankings, category position, and download trends after launching instant experiences. Correlate spikes in instant experience usage with ranking improvements to quantify the ASO value.

Iterating on URL Structure

As you gather data, you may find that certain URL patterns perform better than others. Common optimizations include:

Simplifying long URL paths that users struggle to type or scan
Adding new instant experience entry points for high-traffic pages
Removing underperforming instant experiences to reduce maintenance
Updating query parameter schemas for better attribution tracking

How to Set Up Instant Apps URL Structure