Superwall

You must call configure() before accessing Superwall.instance, otherwise your app will crash.

Purpose

Provides access to the configured Superwall instance after calling configure().

Signature

companion object {
    val instance: Superwall
}

// Java
public static Superwall getInstance()

Parameters

This is a companion object property with no parameters.

Returns / State

Returns the shared Superwall instance that was configured via configure().

Usage

Configure first (typically in Application class):

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        Superwall.configure(
            application = this,
            apiKey = "pk_your_api_key"
        )
    }
}

Then access throughout your app:

Superwall.instance.register("feature_access") {
    // Feature code here
}

Set user identity and attributes:

Superwall.instance.identify("user123")

Superwall.instance.setUserAttributes(mapOf(
    "plan" to "premium",
    "signUpDate" to System.currentTimeMillis()
))

Reset the user:

Superwall.instance.reset()

Avoid calling Superwall.instance.reset() repeatedly. Resetting rotates the anonymous user ID, clears local paywall assignments, and requires the SDK to re-download configuration state. Only trigger a reset when a user explicitly logs out or you intentionally need to forget their identity. See User Management for more guidance.

Set delegate:

Superwall.instance.delegate = this

Consume a purchase (2.6.2+):

// Using coroutines
lifecycleScope.launch {
    val result = Superwall.instance.consume(purchaseToken)
    result.fold(
        onSuccess = { token ->
            println("Purchase consumed: $token")
        },
        onFailure = { error ->
            println("Failed to consume: ${error.message}")
        }
    )
}

// Using callback
Superwall.instance.consume(purchaseToken) { result ->
    result.fold(
        onSuccess = { token ->
            println("Purchase consumed: $token")
        },
        onFailure = { error ->
            println("Failed to consume: ${error.message}")
        }
    )
}

Show an alert over the current paywall (2.5.3+):

Superwall.instance.showAlert(
    title = "Important Notice",
    message = "Your subscription will renew soon",
    actionTitle = "View Details",
    closeActionTitle = "Dismiss",
    action = {
        // Handle action button tap
        navigateToSubscriptionSettings()
    },
    onClose = {
        // Handle close/dismiss
        println("Alert dismissed")
    }
)

Set integration attributes for analytics (2.5.3+):

For Airbridge on Android SDK 2.8.8+, pass the device ID from Airbridge.fetchDeviceUUID() as AttributionProvider.AIRBRIDGE_ID. Superwall sends this value as airbridgeId.

import com.superwall.sdk.models.attribution.AttributionProvider

Superwall.instance.setIntegrationAttributes(
    mapOf(
        AttributionProvider.ADJUST_ID to "adjust_user_id_123",
        AttributionProvider.MIXPANEL to "mixpanel_distinct_id_456",
        AttributionProvider.META to "meta_user_id_789",
        AttributionProvider.GOOGLE_ADS to "google_ads_id_101",
        AttributionProvider.GOOGLE_APP_SET to "google_app_set_id_202",
        AttributionProvider.APPSTACK to "appstack_user_id_303",
        AttributionProvider.AIRBRIDGE_ID to "airbridge_device_id_404"
    )
)

Observe customer info (2.6.6+)

Superwall now exposes purchase history and entitlement snapshots via a StateFlow<CustomerInfo>. Each emission contains merged device, web, and external purchase controller data so you can react to subscription changes without wiring up your own polling layer.

lifecycleScope.launch {
  Superwall.instance.customerInfo.collect { info ->
    val activeProductIds = info.activeSubscriptionProductIds
    val activeEntitlementIds = info.entitlements
      .filter { it.isActive }
      .map { it.id }

    updateUi(
      subscriptions = activeProductIds,
      entitlements = activeEntitlementIds
    )
  }
}

Need an immediate snapshot (for example during cold start)? Call Superwall.instance.getCustomerInfo() to synchronously read the latest cached value, or wire both together:

val cachedInfo = Superwall.instance.getCustomerInfo()
render(cachedInfo)

lifecycleScope.launch {
  Superwall.instance.customerInfo.collect { render(it) }
}

Pair the flow with SuperwallDelegate.customerInfoDidChange(from:to:) when you need to mirror changes into analytics.

Present the Customer Center (2.8.5+)

fun Superwall.presentCustomerCenter(
    configuration: CustomerCenterConfiguration? = null,
    delegate: CustomerCenterDelegate? = null,
    onDismiss: (() -> Unit)? = null
)

fun Superwall.dismissCustomerCenter(completion: (() -> Unit)? = null)

Present the SDK's self-service screen for subscription management, purchase restoration, refunds, and support:

Superwall.instance.presentCustomerCenter(
    onDismiss = {
        // The Customer Center was dismissed.
    }
)

Pass a CustomerCenterConfiguration to override the configuration from SuperwallOptions.customerCenter for this presentation. Pass a CustomerCenterDelegate to handle its callbacks. Call dismissCustomerCenter() to dismiss it programmatically.

Only one Customer Center can be presented at a time. Calls to present it while it is already open do nothing. Call presentation and dismissal methods from the main thread.

Java usage:

// Access the instance
Superwall.getInstance().register("feature_access", () -> {
    // Feature code here
});

// Set user identity
Superwall.getInstance().identify("user123");