Headless authentication SDKs for Android, iOS, and React Native, built on a shared Kotlin Multiplatform core. Bring your own UI — Stytch handles the auth.

Note: This SDK is currently in Public beta. If you are instead looking for the stable version, please see stytch-browser for React Native, stytch-ios for iOS, and stytch-android for Android respectively.

If you're building a consumer-facing app, you want the Consumer SDK. If you're building a B2B SaaS product where your customers belong to organizations, you want the B2B SDK. For a deeper comparison, see the docs.

JVM/Desktop support is functional but limited — platform-specific features such as biometrics, OAuth, and passkeys are not available outside of the mobile platforms.

// settings.gradle.kts
dependencyResolutionManagement {
    repositories {
        mavenCentral()
    }
}

dependencies {
    implementation("com.stytch.sdk:consumer-headless:1.0.0")
}

dependencies {
    implementation("com.stytch.sdk:b2b-headless:1.0.0")
}

dependencies: [
    .package(url: "https://github.com/stytchauth/stytch-io-sdk", from: "1.0.0"),
],
targets: [
    .target(
        name: "YourTarget",
        dependencies: [
            // Pick one:
            .product(name: "StytchConsumerSDK", package: "stytch-ios"),
            // .product(name: "StytchB2BSDK", package: "stytch-ios"),
        ]
    ),
]

npm install @stytch/react-native-consumer
# or
yarn add @stytch/react-native-consumer

npm install @stytch/react-native-b2b
# or
yarn add @stytch/react-native-b2b

{
    "expo": {
        "plugins": [
            [
                "expo-build-properties",
                {
                    "android": {
                        "packagingOptions": {
                            "exclude": ["META-INF/versions/9/OSGI-INF/MANIFEST.MF"],
                        },
                    },
                    "ios": {
                        "useFrameworks": "static",
                    }
                },
            ]
        ]
    }
}

The examples below use the Consumer SDK with an SMS OTP login flow. The B2B SDK follows the same pattern — swap in createStytchB2B / StytchB2BSDK / @stytch/react-native-b2b and use the equivalent B2B endpoints.

import com.stytch.sdk.consumer.createStytchConsumer
import com.stytch.sdk.data.StytchClientConfiguration

val stytch = createStytchConsumer(
    StytchClientConfiguration(
        context = applicationContext,
        publicToken = "public-token-live-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    )
)

import com.stytch.sdk.consumer.data.ConsumerAuthenticationState

lifecycleScope.launch {
    stytch.authenticationStateFlow.collect { state ->
        when (state) {
            is ConsumerAuthenticationState.Authenticated -> { /* user is logged in */ }
            is ConsumerAuthenticationState.Unauthenticated -> { /* show login UI */ }
            is ConsumerAuthenticationState.Loading -> { /* session is being restored */ }
        }
    }
}

import com.stytch.sdk.consumer.networking.models.OTPsAuthenticateParameters
import com.stytch.sdk.consumer.networking.models.OTPsSMSLoginOrCreateParameters

// Send OTP — creates the user if they don't exist yet
val sendResponse = stytch.otp.sms.loginOrCreate(
    OTPsSMSLoginOrCreateParameters(phoneNumber = "+15551234567")
)
val methodId = sendResponse.methodId

// Verify the code the user entered
val authResponse = stytch.otp.authenticate(
    OTPsAuthenticateParameters(
        token = userEnteredCode,
        methodId = methodId,
        sessionDurationMinutes = 30,
    )
)

import StytchConsumerSDK

let stytch = createStytchConsumer(
    configuration: .init(
        publicToken: "public-token-live-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
    )
)

Task {
    for await state in stytch.authenticationStateFlow {
        switch onEnum(of: state) {
        case .authenticated(let s):
            print("Logged in: \(s.user)")
        case .unauthenticated:
            print("Not logged in")
        case .loading:
            print("Loading...")
        }
    }
}

// Send OTP — creates the user if they don't exist yet
let sendParams: OTPsSMSLoginOrCreateParameters = .init(phoneNumber: "+15551234567")
let sendResponse = try await stytch.otp.sms.loginOrCreate(request: sendParams)
let methodId = sendResponse.methodId

// Verify the code the user entered
let authParams: OTPsAuthenticateParameters = .init(
    token: userEnteredCode,
    methodId: methodId,
    sessionDurationMinutes: 30
)
let authResponse = try await stytch.otp.authenticate(request: authParams)

import {
    createStytchConsumer,
    StytchClientConfiguration,
    StytchProvider,
} from '@stytch/react-native-consumer';

const stytch = createStytchConsumer(
    new StytchClientConfiguration("public-token-live-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")
);

export default function App() {
    return (
        <StytchProvider stytch={stytch}>
            <YourNavigator />
        </StytchProvider>
    );
}

import { useStytch, useStytchUser, useStytchSession } from '@stytch/react-native-consumer';

function ProfileHeader() {
    const user = useStytchUser();
    const session = useStytchSession();
    return (
        <Text>{user ? `Logged in as ${user.emails[0]?.email}` : 'Not logged in'}</Text>
    );
}

import { useStytch } from '@stytch/react-native-consumer';

function SmsOtpScreen() {
    const stytch = useStytch();
    const [methodId, setMethodId] = useState<string | null>(null);

    const sendOtp = async (phoneNumber: string) => {
        const response = await stytch.otp.sms.loginOrCreate({ phoneNumber });
        setMethodId(response.methodId);
    };

    const verifyOtp = async (code: string) => {
        await stytch.otp.authenticate({
            token: code,
            methodId: methodId!,
            sessionDurationMinutes: 30,
        });
    };

    // ...
}

By default, all SDK methods are Kotlin suspend functions. If your project uses callback-style APIs — or you're calling the SDK from Java — the *-headless-extensions artifacts provide onSuccess/onFailure overloads for every method, returning a cancellable Job:

// Coroutine style (base SDK):
val result = stytch.otp.authenticate(params)

// Callback style (extensions):
val job = stytch.otp.authenticate(
    request = params,
    onSuccess = { response -> /* handle success */ },
    onFailure = { error -> /* handle error */ },
)

To use the callback extensions, swap the base dependency for the extensions artifact — it re-exports the base module, so no other changes are needed:

// Before:
implementation("com.stytch.sdk:consumer-headless:1.0.0")

// After:
implementation("com.stytch.sdk:consumer-headless-extensions:1.0.0")

// Same for B2B:
implementation("com.stytch.sdk:b2b-headless-extensions:1.0.0")

Callback extensions are available on Android and JVM only. iOS uses native async/await and React Native handles async natively in JavaScript.

Full API documentation is included (KDoc/JavaDoc, DocC, JSDoc) for in-editor reference, as well as hosted here.

For deeper documentation, consult our docs site.

If you have questions, found a bug or want help troubleshooting, join us in Slack or email support@stytch.com.

If you've found a security vulnerability, please follow our responsible disclosure instructions.

We welcome contributions! Please see our Contributing Guide for details on how to submit issues, pull requests, and contribute to the project.

See DEVELOPMENT.md

If you discover a security vulnerability, please report it to us at security@stytch.com. See our Security Policy for more details.

Everyone interacting in Stytch codebases, issue trackers, chat rooms and mailing lists is expected to follow the code of conduct.