App Clip: Key Concepts, Lightweight Version of iOS App

What is App Clip?

App Clip is Apple's technology for iOS that allows launching a small part of a full app without installing it. When a user scans an NFC tag, QR code or App Clip Code, the operating system downloads and opens the App Clip as a card on top of the current screen. Apple designed App Clip for “pay, order or sign up” scenarios — actions that must be performed without friction and waiting.

App Clip works in ephemeral mode. iOS stores App Clip data for a limited time (usually several days or until the user explicitly deletes it). If the user needs the same function again, the App Clip is re-downloaded. Apple intentionally limits App Clip persistence to encourage installing the full app for ongoing use. Data created in the App Clip is automatically transferred to the full app upon installation via CloudKit.

Real examples: scanning an NFC tag on a restaurant table to order and pay (Panera, Pizza Hut), a QR code on a rented scooter to unlock (Lime, Bird), an App Clip Code at a parking meter to pay (PayByPhone), scanning a product in a store to purchase (Shopify). All these scenarios share one thing — a transactional task that benefits from having no installation step.

Launch triggers: NFC, QR, App Clip Code

App Clip is activated through five mechanisms. The most common are NFC tags (tap launches the App Clip), QR codes (camera scanning shows the App Clip card at the bottom of the screen) and App Clip Codes (Apple's proprietary visual codes with a patterned border and built-in NFC tag). App Clip also launches via Safari App Banner and iMessage links.

App Clip Code is Apple's patented technology. Unlike QR codes, App Clip Codes look aesthetic — they support brand colors and a logo in the center, with the URL encoded in sound-like waves around the edges. The code contains a built-in NFC tag, providing a dual launch mechanism: visual scanning and tapping. Apple provides App Clip Code generation tools through the App Store Connect portal.

// SceneDelegate.swift — handling App Clip launch via NSUserActivity
import UIKit

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    func scene(_ scene: UIScene,
                willContinueUserActivityWithType userActivityType: String) {
        // Preparing for incoming NSUserActivity
    }

    func scene(_ scene: UIScene,
                continue userActivity: NSUserActivity) {

        guard let invocationURL = userActivity.webpageURL else { return }

        // Parsing URL and navigating to the required screen
        handleInvocationURL(invocationURL)
    }

    private func handleInvocationURL(_ url: URL) {
        // Example: /order/restaurantID — order screen
        // Example: /pay/parkingID — payment screen
    }
}

All triggers ultimately create an NSUserActivity with a webpageURL parameter that contains the invocation context. The App Clip parses this URL and displays the corresponding screen. App Clip also supports geolocation triggers — iOS can suggest an App Clip when the user is near a specific location (e.g., near a coffee shop with an App Clip).

App Clip development in Swift

App Clip development starts from an existing Xcode project of the full app. You add a new App Clip target — it uses the same project, the same team and most of the shared code. The App Clip target includes only the files, storyboards and resources needed for the specific function. Apple provides an App Clip template with pre-configured entitlements and Info.plist keys.

// AppClip/ProductViewModel.swift — shared logic between App Clip and full app
import Foundation
import StoreKit

class ProductViewModel: ObservableObject {

    @Published var items: [Product] = []
    @Published var total: Decimal = 0

    func checkout() {
        // Sending order via API
    }

    func showInstallPrompt() {
        // Showing SKOverlay to install the full app
        guard let scene = UIApplication.shared()
            .connectedScenes
            .first(where: { $0 is UIWindowScene }) as? UIWindowScene else { return }

        let overlay = SKOverlay(configuration: SKOverlay.AppClipConfiguration(
            position: .bottom
        ))
        overlay.present(in: scene)
    }
}

// AppClip/MainViewController.swift — main App Clip screen
class MainViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        // Compact UI for App Clip card
        // Using SF Symbols to reduce size
        // Loading only data for the current transaction
    }

    @IBAction func openFullApp(_ sender: Any) {
        // Opening app page in the App Store
        guard let url = URL(string: "https://apps.apple.com/app/id123456789") else { return }
        UIApplication.shared.open(url)
    }
}

The App Clip target uses the same Apple Developer Team ID and Bundle ID as the main app (with a .Clip suffix). Key entitlements: com.apple.developer.app-clip and associated domains for URL handling. App Clip supports Apple Pay, Sign in with Apple, StoreKit for purchases and Core Location. Some frameworks are unavailable: background modes, HealthKit, Media Library and certain sensor APIs.

Size limitations and optimization

App Clip size limit is strictly controlled by Apple — no more than 10 MB compressed. The check is performed at the upload stage to App Store; builds exceeding the limit are rejected. The size includes binary code, resources (storyboards, asset catalogs) and linked frameworks. Swift runtime libraries are part of iOS and are not counted, but third-party frameworks increase the size.

Xcode provides an App Clip size report in Organizer after archiving. The report breaks down size by component (code, resources, frameworks) and shows the estimated download size. Apple recommends keeping the App Clip within 8 MB to account for compression variations across different delivery channels.

App Clip user scenario

The App Clip usage scenario consists of four stages. Discovery: the user encounters an NFC tag, QR code or App Clip Code in the physical world. Launch: scanning or tapping loads the App Clip (less than 2 seconds, usually 1 second). Interaction: the App Clip opens as a card with a single function — an order, payment or reservation screen. Completion: the user completes the task and sees an offer to install the full app via SKOverlay or an App Store link.

Apple pays special attention to privacy in App Clip. The system requests camera, geolocation and notification permissions separately for the App Clip. Data created in the App Clip (payment information, preferences) is stored locally and transferred to the full app via CloudKit upon its installation. App Clip cannot request sensitive permissions (Health, Motion, Media Library) — these require installing the full app.

An important feature is SKOverlay, a native iOS element that appears at the bottom of the App Clip screen and offers to install the full app. SKOverlay does not require going to the App Store and works in the context of the current app. The user can install the full app in one tap, and the App Clip automatically transfers all created data after installation.

App Clip vs Android Instant App

Both technologies — App Clip and Android Instant App — solve the same problem: instant launch of a native app without installation, but use different platform approaches. App Clip is more limited (iOS only, smaller ecosystem), but offers deep integration with Apple Pay and the Apple device ecosystem. Instant Apps win with broader Android reach and flexible triggers, including standard QR codes without additional infrastructure.