Build a Self-Service Account Security Interface with My Account API

Documentation Index

Fetch the complete documentation index at: https://auth0-feat-docs-5492.mintlify.app/llms.txt

Use this file to discover all available pages before exploring further.

​

How it works

​

Available components

​

Configure My Account Components using the Auth0 Dashboard

​

Enable the My Account API

1. Navigate to Dashboard > Applications > APIs.
2. Select Activate My Account API to and ensure it is enabled for your tenant.

​

Create an Application and configure My Account API scopes

1. Navigate to Dashboard > Applications.
2. Select Create Application.
3. Select Native.
4. In the Settings tab, add the callback URL in the Allowed Callback URLs:
   • For iOS applications use: https://YOUR_AUTH0_DOMAIN://YOUR_BUNDLE_ID/ios/YOUR_BUNDLE_ID/callback.
   • For Android applications use: https://YOUR_AUTH0_DOMAIN://YOUR_PACKAGE_NAME/android/YOUR_PACKAGE_NAME/callback.
5. Add your logout URLs in the Allowed Logout URLs.
6. Select the API Access Tab.
7. Select Edit for the Auth0 My Account API to select the User delegated Access permissions:

​

Configure scopes

create:me:authentication_methods
read:me:authentication_methods
update:me:authentication_methods
delete:me:authentication_methods

​

Configure passkeys (optional)

1. Navigate to Dashboard > Authentication > Database. Open the database connection you want passkeys enabled on.
2. Under Passkey settings, toggle Require Passkey Enrollment as needed for your policy.
3. Register your mobile applications so the platform authenticator can issue credentials for your Auth0 tenant:
   • For iOS applications add: your application’s bundle ID under Allowed iOS Applications.
   • For Android applications add: your applications’s package name and SHA-256 signing fingerprints under Allowed Android Applications. Obtain the fingerprint with keytool -list -v -keystore /path/to/keystore -alias YOUR_ALIAS | grep SHA256, or copy it from Play Console > Setup > App signing for Play App Signing.

​

Configure your application

import SwiftUI
import Auth0
import Auth0UniversalComponents

@main
struct MyApp: App {
    init() {
        Auth0UniversalComponentsSDKInitializer.initialize(
            tokenProvider: CredentialsManager(authentication: Auth0.authentication())
        )
    }

    var body: some Scene {
        WindowGroup { ContentView() }
    }
}

Auth0UniversalComponentsSDKInitializer.initialize(
    domain: "YOUR_AUTH0_DOMAIN",
    clientId: "YOUR_CLIENT_ID",
    audience: "https://YOUR_AUTH0_DOMAIN/me/",
    tokenProvider: CredentialsManager(authentication: Auth0.authentication())
)

struct AppTokenProvider: TokenProvider {
    func fetchCredentials() async throws -> Credentials {
        // Return the user's login credentials.
    }
    func storeCredentials(credentials: Credentials) {
        // Persist new or refreshed credentials.
    }
    func store(apiCredentials: APICredentials, for audience: String) {
        // Persist My Account API credentials keyed by audience.
    }
    func fetchAPICredentials(audience: String, scope: String) async throws -> APICredentials {
        // Return cached My Account API credentials, refreshing if expired.
    }
}

let passkeys = PasskeysConfiguration(
    userIdentityId: "auth0|abc123",
    connection: "Username-Password-Authentication"
)

Auth0UniversalComponentsSDKInitializer.initialize(
    passkeyConfiguration: passkeys,
    tokenProvider: credentialsManager
)

    webcredentials:YOUR_AUTH0_DOMAIN

import com.auth0.android.Auth0
import com.auth0.android.authentication.AuthenticationAPIClient
import com.auth0.android.authentication.storage.CredentialsManager
import com.auth0.android.authentication.storage.SharedPreferencesStorage
import com.auth0.universalcomponents.Auth0UniversalComponents
import com.auth0.universalcomponents.token.DefaultTokenProvider

class MainActivity : ComponentActivity() {

    private val account by lazy {
        Auth0.getInstance(
            getString(R.string.com_auth0_client_id),
            getString(R.string.com_auth0_domain)
        )
    }

    private val credentialsManager by lazy {
        CredentialsManager(
            AuthenticationAPIClient(account),
            SharedPreferencesStorage(this)
        )
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        Auth0UniversalComponents.initialize(
            account = account,
            tokenProvider = DefaultTokenProvider(credentialsManager),
            scheme = getString(R.string.com_auth0_scheme)
        )

        setContent { MyApp() }
    }
}

class AppTokenProvider : TokenProvider {
    override suspend fun fetchCredentials(): Credentials {
        // Return the user's login credentials.
    }
    override suspend fun fetchApiCredentials(
        audience: String,
        scope: String?
    ): APICredentials {
        // Return cached My Account API credentials, refreshing if expired.
    }
    override suspend fun saveApiCredentials(
        audience: String,
        credentials: APICredentials
    ) {
        // Persist the freshly issued API credentials.
    }
}

import androidx.credentials.CredentialManager
import com.auth0.universalcomponents.PasskeyConfiguration

val passkeyConfiguration = PasskeyConfiguration(
    credentialManager = CredentialManager.create(this),
    connection = "Username-Password-Authentication",
    userIdentity = "auth0|abc123"
)

Auth0UniversalComponents.initialize(
    account = account,
    tokenProvider = DefaultTokenProvider(credentialsManager),
    scheme = getString(R.string.com_auth0_scheme),
    passkeyConfiguration = passkeyConfiguration
)