> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dynamic.xyz/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# MFA & Passkeys API Reference

> Complete API reference for multi-factor authentication and passkey operations in the Dynamic Swift SDK.

## MFA Operations

### getUserDevices

Fetch all MFA devices for the authenticated user.

```swift theme={"system"}
func getUserDevices() async throws -> [MfaDevice]
```

**Returns:** Array of `MfaDevice` objects

**Example:**

```swift theme={"system"}
let sdk = DynamicSDK.instance()
let devices = try await sdk.mfa.getUserDevices()
```

### addDevice

Add a new TOTP device for the user.

```swift theme={"system"}
func addDevice(type: String) async throws -> MfaAddDevice
```

**Parameters:**

* `type` - Device type (e.g., `"totp"`)

**Returns:** `MfaAddDevice` containing the secret for authenticator setup

**Example:**

```swift theme={"system"}
let sdk = DynamicSDK.instance()
let result = try await sdk.mfa.addDevice(type: "totp")
print("Secret: \(result.secret)")
```

### verifyDevice

Verify a newly added device with a TOTP code.

```swift theme={"system"}
func verifyDevice(_ code: String, type: String) async throws
```

**Parameters:**

* `code` - The 6-digit TOTP code from the authenticator app
* `type` - Device type (e.g., `"totp"`)

**Example:**

```swift theme={"system"}
let sdk = DynamicSDK.instance()
try await sdk.mfa.verifyDevice("123456", type: "totp")
```

### authenticateDevice

Authenticate an MFA device with a TOTP code.

```swift theme={"system"}
func authenticateDevice(params: MfaAuthenticateDevice) async throws -> String?
```

**Parameters:**

* `params` - Authentication parameters including code, device ID, and token options

**Returns:** MFA authentication token (optional)

**Example:**

```swift theme={"system"}
let sdk = DynamicSDK.instance()
let mfaToken = try await sdk.mfa.authenticateDevice(
    params: MfaAuthenticateDevice(
        code: "123456",
        deviceId: "device_id",
        createMfaToken: MfaCreateToken(singleUse: false)
    )
)
```

### deleteUserDevice

Delete an MFA device from the user's account.

```swift theme={"system"}
func deleteUserDevice(deviceId: String, mfaAuthToken: String) async throws
```

**Parameters:**

* `deviceId` - ID of the device to delete
* `mfaAuthToken` - MFA authentication token

**Example:**

```swift theme={"system"}
let sdk = DynamicSDK.instance()
try await sdk.mfa.deleteUserDevice(
    deviceId: "device_id",
    mfaAuthToken: mfaToken
)
```

### getRecoveryCodes

Retrieve backup recovery codes for the user.

```swift theme={"system"}
func getRecoveryCodes(generateNewCodes: Bool) async throws -> [String]
```

**Parameters:**

* `generateNewCodes` - Whether to generate new codes or retrieve existing ones

**Returns:** Array of recovery code strings

**Example:**

```swift theme={"system"}
let sdk = DynamicSDK.instance()
let codes = try await sdk.mfa.getRecoveryCodes(generateNewCodes: false)
```

### getNewRecoveryCodes

Generate new recovery codes, invalidating old ones.

```swift theme={"system"}
func getNewRecoveryCodes() async throws -> [String]
```

**Returns:** Array of new recovery code strings

**Example:**

```swift theme={"system"}
let sdk = DynamicSDK.instance()
let newCodes = try await sdk.mfa.getNewRecoveryCodes()

// User must acknowledge the new codes
try await sdk.mfa.completeAcknowledgement()
```

### isPendingRecoveryCodesAcknowledgment

Check if recovery codes need acknowledgment.

```swift theme={"system"}
func isPendingRecoveryCodesAcknowledgment() async throws -> Bool
```

**Returns:** Boolean indicating if acknowledgment is pending

**Example:**

```swift theme={"system"}
let sdk = DynamicSDK.instance()
let isPending = try await sdk.mfa.isPendingRecoveryCodesAcknowledgment()
```

### completeAcknowledgement

Acknowledge that user has saved their recovery codes.

```swift theme={"system"}
func completeAcknowledgement() async throws
```

**Example:**

```swift theme={"system"}
let sdk = DynamicSDK.instance()
try await sdk.mfa.completeAcknowledgement()
```

### authenticateRecoveryCode

Authenticate using a recovery code.

```swift theme={"system"}
func authenticateRecoveryCode(code: MfaAuthenticateRecoveryCode) async throws -> String?
```

**Parameters:**

* `code` - Recovery code and token creation options

**Returns:** MFA authentication token (optional)

**Example:**

```swift theme={"system"}
let sdk = DynamicSDK.instance()
let mfaToken = try await sdk.mfa.authenticateRecoveryCode(
    code: MfaAuthenticateRecoveryCode(
        code: "recovery_code",
        createMfaToken: MfaCreateToken(singleUse: true)
    )
)
```

## Passkey Operations

### signIn

Sign in using an existing passkey.

```swift theme={"system"}
func signIn() async throws -> SdkUser
```

**Returns:** `SdkUser` object for the authenticated user

**Example:**

```swift theme={"system"}
let sdk = DynamicSDK.instance()
let user = try await sdk.auth.passkey.signIn()
```

### registerPasskey

Register a new passkey for the authenticated user.

```swift theme={"system"}
func registerPasskey() async throws -> PasskeyRegistrationResult
```

**Returns:** Registration result

**Example:**

```swift theme={"system"}
let sdk = DynamicSDK.instance()
_ = try await sdk.passkeys.registerPasskey()
```

### getPasskeys

Fetch all passkeys registered for the user.

```swift theme={"system"}
func getPasskeys() async throws -> [UserPasskey]
```

**Returns:** Array of `UserPasskey` objects

**Example:**

```swift theme={"system"}
let sdk = DynamicSDK.instance()
let passkeys = try await sdk.passkeys.getPasskeys()
```

### authenticatePasskeyMFA

Authenticate with a passkey for MFA.

```swift theme={"system"}
func authenticatePasskeyMFA(
    createMfaToken: MfaCreateToken,
    relatedOriginRpId: String?
) async throws -> PasskeyMfaResponse
```

**Parameters:**

* `createMfaToken` - Token creation options
* `relatedOriginRpId` - Optional related origin RP ID

**Returns:** `PasskeyMfaResponse` containing JWT token

**Example:**

```swift theme={"system"}
let sdk = DynamicSDK.instance()
let response = try await sdk.passkeys.authenticatePasskeyMFA(
    createMfaToken: MfaCreateToken(singleUse: true),
    relatedOriginRpId: nil
)
print("Token: \(response.jwt ?? "nil")")
```

### deletePasskey

Delete a passkey from the user's account.

```swift theme={"system"}
func deletePasskey(_ request: DeletePasskeyRequest) async throws
```

**Parameters:**

* `request` - Delete request containing the passkey ID

**Example:**

```swift theme={"system"}
let sdk = DynamicSDK.instance()
try await sdk.passkeys.deletePasskey(
    DeletePasskeyRequest(passkeyId: "passkey_id")
)
```

## Data Types

### MfaDevice

Represents an MFA device.

```swift theme={"system"}
struct MfaDevice {
    let id: String?
    let type: MfaDeviceType?
    let createdAt: String?
}
```

### MfaAddDevice

Result of adding a new MFA device.

```swift theme={"system"}
struct MfaAddDevice {
    let secret: String
}
```

### MfaAuthenticateDevice

Parameters for device authentication.

```swift theme={"system"}
struct MfaAuthenticateDevice {
    let code: String
    let deviceId: String
    let createMfaToken: MfaCreateToken
}
```

### MfaCreateToken

Token creation options for MFA.

```swift theme={"system"}
struct MfaCreateToken {
    let singleUse: Bool
}
```

### MfaAuthenticateRecoveryCode

Parameters for recovery code authentication.

```swift theme={"system"}
struct MfaAuthenticateRecoveryCode {
    let code: String
    let createMfaToken: MfaCreateToken
}
```

### UserPasskey

Represents a user's passkey.

```swift theme={"system"}
struct UserPasskey {
    let id: String
    let createdAt: Date
    let lastUsedAt: Date?
    let isDefault: Bool?
}
```

### DeletePasskeyRequest

Request to delete a passkey.

```swift theme={"system"}
struct DeletePasskeyRequest {
    let passkeyId: String
}
```

### PasskeyMfaResponse

Response from passkey MFA authentication.

```swift theme={"system"}
struct PasskeyMfaResponse {
    let jwt: String?
}
```

## Error Handling

All MFA and passkey operations can throw errors. Handle them appropriately:

```swift theme={"system"}
let sdk = DynamicSDK.instance()

do {
    let devices = try await sdk.mfa.getUserDevices()
} catch {
    print("Error: \(error.localizedDescription)")
}
```

## See Also

* **[MFA Guide](/swift/mfa)** - Complete guide to implementing MFA
* **[Passkey Authentication](/swift/authentication)** - Passkey setup and usage
* **[Authentication Guide](/swift/sdk-reference/authentication)** - Basic authentication methods