# Superwall

The shared instance of Superwall that provides access to all SDK features.

> **Note**

You must call [`configure()`](/docs/android/sdk-reference/configure) before accessing `Superwall.instance`, otherwise your app will crash.



Purpose [#purpose]

Provides access to the configured Superwall instance after calling [`configure()`](/docs/android/sdk-reference/configure).

Signature [#signature]

```kotlin
companion object {
    val instance: Superwall
}
```

```java
// Java
public static Superwall getInstance()
```

Parameters [#parameters]

This is a companion object property with no parameters.

Returns / State [#returns--state]

Returns the shared `Superwall` instance that was configured via [`configure()`](/docs/android/sdk-reference/configure).

Usage [#usage]

Configure first (typically in Application class):

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

Then access throughout your app:

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

Set user identity and attributes:

```kotlin
Superwall.instance.identify("user123")

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

Reset the user:

```kotlin
Superwall.instance.reset()
```

> **Note**

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](/docs/android/quickstart/user-management) for more guidance.



Set delegate:

```kotlin
Superwall.instance.delegate = this
```

Consume a purchase (2.6.2+):

```kotlin
// 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+):

```kotlin
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+):

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

Superwall.instance.setIntegrationAttributes(
    mapOf(
        AttributionProvider.ADJUST 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"
    )
)
```

Observe customer info (2.6.6+) [#observe-customer-info-266]

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.

```kotlin
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:

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

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

Pair the flow with [`SuperwallDelegate.customerInfoDidChange(from:to:)`](/docs/android/sdk-reference/SuperwallDelegate#customerinfodidchangefrom-customerinfo-to-customerinfo) when you need to mirror changes into analytics.

Java usage:

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

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