diff --git a/example/android/app/src/main/AndroidManifest.xml b/example/android/app/src/main/AndroidManifest.xml
index 5c7a7ab0e4..a2cf1c61c0 100644
--- a/example/android/app/src/main/AndroidManifest.xml
+++ b/example/android/app/src/main/AndroidManifest.xml
@@ -1,10 +1,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
     <uses-permission android:name="android.permission.INTERNET" />
-
     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
-
     <uses-permission android:name="android.permission.CAMERA" />
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
diff --git a/example/android/build.gradle b/example/android/build.gradle
index df1ce4db3b..c83c9a0749 100644
--- a/example/android/build.gradle
+++ b/example/android/build.gradle
@@ -1,7 +1,7 @@
 buildscript {
     ext {
         buildToolsVersion = "34.0.0"
-        minSdkVersion = 23
+        minSdkVersion = 24
         compileSdkVersion = 34
         targetSdkVersion = 34
         ndkVersion = "26.1.10909125"
diff --git a/example/ios/VisionCameraExample.xcodeproj/project.pbxproj b/example/ios/VisionCameraExample.xcodeproj/project.pbxproj
index 829ad9100d..8f5892d0c2 100644
--- a/example/ios/VisionCameraExample.xcodeproj/project.pbxproj
+++ b/example/ios/VisionCameraExample.xcodeproj/project.pbxproj
@@ -181,7 +181,6 @@
 				LastUpgradeCheck = 1250;
 				TargetAttributes = {
 					13B07F861A680F5B00A75B9A = {
-						DevelopmentTeam = CJW62Q77E7;
 						LastSwiftMigration = 1240;
 					};
 				};
@@ -422,7 +421,7 @@
 				CLANG_CXX_LANGUAGE_STANDARD = "c++20";
 				CLANG_ENABLE_MODULES = YES;
 				CURRENT_PROJECT_VERSION = 1;
-				DEVELOPMENT_TEAM = CJW62Q77E7;
+				DEVELOPMENT_TEAM = "";
 				ENABLE_BITCODE = NO;
 				INFOPLIST_FILE = VisionCameraExample/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = "Vision Camera";
@@ -455,7 +454,7 @@
 				CLANG_CXX_LANGUAGE_STANDARD = "c++20";
 				CLANG_ENABLE_MODULES = YES;
 				CURRENT_PROJECT_VERSION = 1;
-				DEVELOPMENT_TEAM = CJW62Q77E7;
+				DEVELOPMENT_TEAM = "";
 				INFOPLIST_FILE = VisionCameraExample/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = "Vision Camera";
 				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.photography";
diff --git a/example/src/CameraPage.tsx b/example/src/CameraPage.tsx
index af65e71462..fc8cdc5ee3 100644
--- a/example/src/CameraPage.tsx
+++ b/example/src/CameraPage.tsx
@@ -1,22 +1,24 @@
 import * as React from 'react'
-import { useRef, useState, useCallback, useMemo } from 'react'
+import { useRef, useState, useCallback, useMemo, useEffect } from 'react'
 import type { GestureResponderEvent } from 'react-native'
 import { StyleSheet, Text, View } from 'react-native'
 import type { PinchGestureHandlerGestureEvent } from 'react-native-gesture-handler'
 import { PinchGestureHandler, TapGestureHandler } from 'react-native-gesture-handler'
 import type { CameraProps, CameraRuntimeError, PhotoFile, VideoFile } from 'react-native-vision-camera'
 import {
-  runAtTargetFps,
+  useAudioInputDevices,
   useCameraDevice,
   useCameraFormat,
-  useFrameProcessor,
   useLocationPermission,
   useMicrophonePermission,
+  AudioInputLevel,
+  useFrameProcessor,
+  runAtTargetFps,
 } from 'react-native-vision-camera'
 import { Camera } from 'react-native-vision-camera'
 import { CONTENT_SPACING, CONTROL_BUTTON_SIZE, MAX_ZOOM_FACTOR, SAFE_AREA_PADDING, SCREEN_HEIGHT, SCREEN_WIDTH } from './Constants'
 import Reanimated, { Extrapolate, interpolate, useAnimatedGestureHandler, useAnimatedProps, useSharedValue } from 'react-native-reanimated'
-import { useEffect } from 'react'
+
 import { useIsForeground } from './hooks/useIsForeground'
 import { StatusBarBlurBackground } from './views/StatusBarBlurBackground'
 import { CaptureButton } from './views/CaptureButton'
@@ -27,6 +29,7 @@ import type { Routes } from './Routes'
 import type { NativeStackScreenProps } from '@react-navigation/native-stack'
 import { useIsFocused } from '@react-navigation/core'
 import { usePreferredCameraDevice } from './hooks/usePreferredCameraDevice'
+import { useSafeAreaInsets } from 'react-native-safe-area-context'
 import { examplePlugin } from './frame-processors/ExamplePlugin'
 import { exampleKotlinSwiftPlugin } from './frame-processors/ExampleKotlinSwiftPlugin'
 
@@ -39,13 +42,15 @@ const SCALE_FULL_ZOOM = 3
 
 type Props = NativeStackScreenProps<Routes, 'CameraPage'>
 export function CameraPage({ navigation }: Props): React.ReactElement {
+  const audioInputDevices = useAudioInputDevices()
+  const { bottom } = useSafeAreaInsets()
+  const [selectedMic, setSelectedMic] = useState(audioInputDevices[0])
   const camera = useRef<Camera>(null)
   const [isCameraInitialized, setIsCameraInitialized] = useState(false)
   const microphone = useMicrophonePermission()
   const location = useLocationPermission()
   const zoom = useSharedValue(1)
   const isPressingButton = useSharedValue(false)
-
   // check if camera page is active
   const isFocussed = useIsFocused()
   const isForeground = useIsForeground()
@@ -189,6 +194,16 @@ export function CameraPage({ navigation }: Props): React.ReactElement {
     })
   }, [])
 
+  useEffect(() => {
+    AudioInputLevel.setPreferredAudioInputDevice(selectedMic?.uid)
+    const subscription = AudioInputLevel.addAudioLevelChangedListener((level) => {
+      console.log('Current Audio device level:', level)
+    })
+    return () => {
+      subscription.remove()
+    }
+  }, [selectedMic?.uid])
+
   const videoHdr = format?.supportsVideoHdr && enableHdr
   const photoHdr = format?.supportsPhotoHdr && enableHdr && !videoHdr
 
@@ -201,6 +216,7 @@ export function CameraPage({ navigation }: Props): React.ReactElement {
               <ReanimatedCamera
                 style={StyleSheet.absoluteFill}
                 device={device}
+                audioInputDevice={selectedMic}
                 isActive={isActive}
                 ref={camera}
                 onInitialized={onInitialized}
@@ -283,6 +299,15 @@ export function CameraPage({ navigation }: Props): React.ReactElement {
           <IonIcon name="qr-code-outline" color="white" size={24} />
         </PressableOpacity>
       </View>
+      <View style={[styles.microphoneContainer, { bottom }]}>
+        {audioInputDevices.map((item, index) => (
+          <PressableOpacity key={`mic-${index}`} onPress={() => setSelectedMic(item)} style={styles.microphoneButton}>
+            <Text style={[styles.microphoneButtonText, item.uid === selectedMic?.uid && styles.microphoneButtonSelectedText]}>
+              {item.portType}
+            </Text>
+          </PressableOpacity>
+        ))}
+      </View>
     </View>
   )
 }
@@ -322,4 +347,18 @@ const styles = StyleSheet.create({
     justifyContent: 'center',
     alignItems: 'center',
   },
+  microphoneContainer: {
+    position: 'absolute',
+    left: 12,
+    top: 100,
+  },
+  microphoneButton: {
+    height: 48,
+  },
+  microphoneButtonText: {
+    color: 'white',
+  },
+  microphoneButtonSelectedText: {
+    color: 'blue',
+  },
 })
diff --git a/package/android/build.gradle b/package/android/build.gradle
index b1d9973d0b..fd51f8f2d4 100644
--- a/package/android/build.gradle
+++ b/package/android/build.gradle
@@ -121,7 +121,7 @@ android {
   }
 
   defaultConfig {
-    minSdkVersion safeExtGet("minSdkVersion", 21)
+    minSdkVersion safeExtGet("minSdkVersion", 24)
     compileSdkVersion safeExtGet("compileSdkVersion", 34)
     targetSdkVersion safeExtGet("targetSdkVersion", 34)
     versionCode 1
diff --git a/package/android/src/main/java/com/mrousavy/camera/core/CameraConfiguration.kt b/package/android/src/main/java/com/mrousavy/camera/core/CameraConfiguration.kt
index f91ce830bb..bd9383ff25 100644
--- a/package/android/src/main/java/com/mrousavy/camera/core/CameraConfiguration.kt
+++ b/package/android/src/main/java/com/mrousavy/camera/core/CameraConfiguration.kt
@@ -13,8 +13,9 @@ import com.mrousavy.camera.core.types.VideoStabilizationMode
 data class CameraConfiguration(
   // Input
   var cameraId: String? = null,
-
   // Outputs
+
+  var audioInputDeviceUid: String? = null,
   var preview: Output<Preview> = Output.Disabled.create(),
   var photo: Output<Photo> = Output.Disabled.create(),
   var video: Output<Video> = Output.Disabled.create(),
@@ -106,10 +107,12 @@ data class CameraConfiguration(
     // (outputOrientation) changed
     val orientationChanged: Boolean,
     // (locationChanged) changed
-    val locationChanged: Boolean
+    val locationChanged: Boolean,
+    // Audio Input changed (audioInputDeviceUid)
+    val audioDeviceChanged: Boolean,
   ) {
     val hasChanges: Boolean
-      get() = deviceChanged || outputsChanged || sidePropsChanged || isActiveChanged || orientationChanged || locationChanged
+      get() = deviceChanged || outputsChanged || sidePropsChanged || isActiveChanged || orientationChanged || locationChanged || audioDeviceChanged
   }
 
   /**
@@ -148,13 +151,16 @@ data class CameraConfiguration(
 
       val locationChanged = left?.enableLocation != right.enableLocation
 
+      val audioDeviceChanged = left?.audioInputDeviceUid != right.audioInputDeviceUid
+
       return Difference(
         deviceChanged,
         outputsChanged,
         sidePropsChanged,
         isActiveChanged,
         orientationChanged,
-        locationChanged
+        locationChanged,
+        audioDeviceChanged
       )
     }
   }
diff --git a/package/android/src/main/java/com/mrousavy/camera/core/CameraError.kt b/package/android/src/main/java/com/mrousavy/camera/core/CameraError.kt
index 3656930007..596b289486 100644
--- a/package/android/src/main/java/com/mrousavy/camera/core/CameraError.kt
+++ b/package/android/src/main/java/com/mrousavy/camera/core/CameraError.kt
@@ -247,3 +247,4 @@ class RecordingWhileFrameProcessingUnavailable :
   )
 
 class UnknownCameraError(cause: Throwable?) : CameraError("unknown", "unknown", cause?.message ?: "An unknown camera error occured.", cause)
+class MediaRecorderFailed
diff --git a/package/android/src/main/java/com/mrousavy/camera/core/CameraSession+Audio.kt b/package/android/src/main/java/com/mrousavy/camera/core/CameraSession+Audio.kt
new file mode 100644
index 0000000000..33da4342bc
--- /dev/null
+++ b/package/android/src/main/java/com/mrousavy/camera/core/CameraSession+Audio.kt
@@ -0,0 +1,78 @@
+package com.mrousavy.camera.core
+
+import android.annotation.SuppressLint
+import android.media.MediaRecorder
+import android.os.Build
+import androidx.annotation.OptIn
+import androidx.camera.video.ExperimentalPersistentRecording
+import com.mrousavy.camera.core.utils.OutputFile
+
+// handle Audio Recording errors here
+@OptIn(ExperimentalPersistentRecording::class)
+@SuppressLint("MissingPermission", "RestrictedApi")
+fun CameraSession.startAudioRecording(
+  enableAudio: Boolean,
+  onError: (error: CameraError) -> Unit
+) {
+  if (enableAudio) {
+    checkMicrophonePermission()
+  }
+  val audioOut = OutputFile(context, context.cacheDir, ".m4a")
+  audioOutputFile = audioOut.file
+
+    audioRecorder = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      MediaRecorder(context)
+    } else {
+      // used for lower api levels
+      MediaRecorder()
+    }
+    audioRecorder?.setAudioSource(MediaRecorder.AudioSource.MIC)
+    audioRecorder?.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
+    audioRecorder?.setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
+    audioRecorder?.setAudioSamplingRate(44100)
+    audioRecorder?.setAudioChannels(1)
+    audioRecorder?.setAudioEncodingBitRate(128_000)
+
+    val outFile = audioOut.file
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      audioRecorder?.setOutputFile(outFile)
+    } else {
+      // used for lower api levels
+      audioRecorder?.setOutputFile(outFile.absolutePath)
+    }
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+      audioRecorder?.preferredDevice = audioDevice
+    }
+    audioRecorder?.prepare()
+    audioRecorder?.start()
+
+}
+
+fun CameraSession.stopAudioRecording() {
+  if (audioRecorder != null) {
+    audioRecorder?.stop()
+    audioRecorder?.release()
+    this.audioRecorder = null
+  }
+
+}
+
+fun CameraSession.cancelAudioRecording() {
+  isRecordingCanceled = true
+  stopAudioRecording()
+}
+
+fun CameraSession.pauseAudioRecording() {
+  val audioRecorder = audioRecorder ?: throw NoRecordingInProgressError()
+  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+    audioRecorder.pause()
+  }
+}
+
+fun CameraSession.resumeAudioRecording() {
+  val audioRecorder = audioRecorder ?: throw NoRecordingInProgressError()
+  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+    audioRecorder.resume()
+  }
+}
+
diff --git a/package/android/src/main/java/com/mrousavy/camera/core/CameraSession+Configuration.kt b/package/android/src/main/java/com/mrousavy/camera/core/CameraSession+Configuration.kt
index 1e9c0def64..f1893395dc 100644
--- a/package/android/src/main/java/com/mrousavy/camera/core/CameraSession+Configuration.kt
+++ b/package/android/src/main/java/com/mrousavy/camera/core/CameraSession+Configuration.kt
@@ -1,6 +1,9 @@
 package com.mrousavy.camera.core
 
 import android.annotation.SuppressLint
+import android.content.Context
+import android.media.AudioDeviceInfo
+import android.media.AudioManager
 import android.util.Log
 import androidx.annotation.OptIn
 import androidx.camera.core.CameraSelector
@@ -41,8 +44,22 @@ private fun assertFormatRequirement(
   }
 }
 
+fun getInputDevice(audioInputDeviceUid: String?, context: Context): AudioDeviceInfo {
+  val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+  val inputDevices = audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS)
+
+  val inputDevice = if (audioInputDeviceUid != null) {
+    inputDevices.firstOrNull { device ->
+      device.id.toString() == audioInputDeviceUid
+    }
+  } else {
+    null
+  }
+  return inputDevice ?: inputDevices.first()
+}
+
 @OptIn(ExperimentalGetImage::class)
-@SuppressLint("RestrictedApi")
+@SuppressLint("RestrictedApi", "NewApi")
 @Suppress("LiftReturnOrAssignment")
 internal fun CameraSession.configureOutputs(configuration: CameraConfiguration) {
   val cameraId = configuration.cameraId!!
@@ -50,6 +67,7 @@ internal fun CameraSession.configureOutputs(configuration: CameraConfiguration)
   val fpsRange = configuration.targetFpsRange
   val format = configuration.format
 
+
   Log.i(CameraSession.TAG, "Using FPS Range: $fpsRange")
 
   val photoConfig = configuration.photo as? CameraConfiguration.Output.Enabled<CameraConfiguration.Photo>
@@ -143,6 +161,8 @@ internal fun CameraSession.configureOutputs(configuration: CameraConfiguration)
           }
         }
       }.build()
+
+
     }
 
     val video = VideoCapture.Builder(recorder).also { video ->
@@ -347,3 +367,9 @@ internal fun CameraSession.configureIsActive(config: CameraConfiguration) {
     lifecycleRegistry.currentState = Lifecycle.State.CREATED
   }
 }
+
+
+internal fun CameraSession.configureAudioDevice(configuration: CameraConfiguration, context: Context) {
+  audioDevice = getInputDevice(configuration.audioInputDeviceUid, context)
+  Log.i(CameraSession.TAG, audioDevice?.id.toString())
+}
diff --git a/package/android/src/main/java/com/mrousavy/camera/core/CameraSession+Video.kt b/package/android/src/main/java/com/mrousavy/camera/core/CameraSession+Video.kt
index fcc54b8e95..8dda453716 100644
--- a/package/android/src/main/java/com/mrousavy/camera/core/CameraSession+Video.kt
+++ b/package/android/src/main/java/com/mrousavy/camera/core/CameraSession+Video.kt
@@ -1,6 +1,7 @@
 package com.mrousavy.camera.core
 
 import android.annotation.SuppressLint
+import android.os.Build
 import android.util.Log
 import android.util.Size
 import androidx.annotation.OptIn
@@ -33,10 +34,19 @@ fun CameraSession.startRecording(
 
   // TODO: Move this to JS so users can prepare recordings earlier
   // Prepare recording
+  videoOutput.output.streamInfo
   var pendingRecording = videoOutput.output.prepareRecording(context, outputOptions)
+  recordingWithExternalAudio = enableAudio
   if (enableAudio) {
-    checkMicrophonePermission()
-    pendingRecording = pendingRecording.withAudioEnabled()
+    try {
+      startAudioRecording(true, onError)
+    } catch (e: Throwable) {
+      onError(EncoderError(e))
+      return
+    }
+  }
+  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+    pendingRecording.withAudioEnabled(true)
   }
   pendingRecording = pendingRecording.asPersistentRecording()
 
@@ -74,14 +84,44 @@ fun CameraSession.startRecording(
             return@start
           }
         }
-
-        // Prepare output result
-        val durationMs = event.recordingStats.recordedDurationNanos / 1_000_000
-        Log.i(CameraSession.TAG, "Successfully completed video recording! Captured ${durationMs.toDouble() / 1_000.0} seconds.")
-        val path = event.outputResults.outputUri.path ?: throw UnknownRecorderError(false, null)
+        val rawVideoPath = event.outputResults.outputUri.path ?: throw UnknownRecorderError(false, null)
         val size = videoOutput.attachedSurfaceResolution ?: Size(0, 0)
-        val video = Video(path, durationMs, size)
+        val durationMs = event.recordingStats.recordedDurationNanos / 1_000_000
+
+        val finalFile = options.file.file
+        val audioFile = audioOutputFile
+        val canMux = recordingWithExternalAudio && audioFile != null && audioFile.exists() && audioFile.length() > 0L
+
+        if (canMux) {
+          try {
+            val tmpMux = java.io.File(finalFile.parentFile, finalFile.nameWithoutExtension + "-muxed.mp4")
+            com.mrousavy.camera.core.utils.MediaMuxerUtils.muxMp4(
+              videoPath = rawVideoPath,
+              audioPath = audioFile!!.absolutePath,
+              outputPath = tmpMux.absolutePath
+            )
+            finalFile.delete()
+            tmpMux.renameTo(finalFile)
+          } catch (e: Throwable) {
+            Log.e(CameraSession.TAG, "Muxing failed!", e)
+            onError(EncoderError(e))
+            return@start
+          } finally {
+            recordingWithExternalAudio = false
+            try { audioFile?.delete() } catch (_: Throwable) {}
+            audioOutputFile = null
+          }
+        } else {
+          // No audio or empty audio — just return the raw video
+          recordingWithExternalAudio = false
+          try { audioFile?.delete() } catch (_: Throwable) {}
+          audioOutputFile = null
+        }
+
+        val finalPath = finalFile.absolutePath
+        val video = Video(finalPath, durationMs, size)
         callback(video)
+
       }
     }
   }
@@ -89,7 +129,7 @@ fun CameraSession.startRecording(
 
 fun CameraSession.stopRecording() {
   val recording = recording ?: throw NoRecordingInProgressError()
-
+  stopAudioRecording()
   recording.stop()
   this.recording = null
 }
@@ -97,14 +137,17 @@ fun CameraSession.stopRecording() {
 fun CameraSession.cancelRecording() {
   isRecordingCanceled = true
   stopRecording()
+  cancelAudioRecording()
 }
 
 fun CameraSession.pauseRecording() {
   val recording = recording ?: throw NoRecordingInProgressError()
   recording.pause()
+  pauseAudioRecording()
 }
 
 fun CameraSession.resumeRecording() {
   val recording = recording ?: throw NoRecordingInProgressError()
   recording.resume()
+  resumeAudioRecording()
 }
diff --git a/package/android/src/main/java/com/mrousavy/camera/core/CameraSession.kt b/package/android/src/main/java/com/mrousavy/camera/core/CameraSession.kt
index 13f6a763c1..48086224a0 100644
--- a/package/android/src/main/java/com/mrousavy/camera/core/CameraSession.kt
+++ b/package/android/src/main/java/com/mrousavy/camera/core/CameraSession.kt
@@ -3,7 +3,13 @@ package com.mrousavy.camera.core
 import android.Manifest
 import android.content.Context
 import android.content.pm.PackageManager
+import android.media.AudioDeviceInfo
 import android.media.AudioManager
+import android.media.AudioRecord
+import android.media.MediaCodec
+import android.media.MediaMuxer
+import android.media.MediaRecorder
+import android.os.Build
 import android.util.Log
 import androidx.annotation.MainThread
 import androidx.camera.core.Camera
@@ -43,7 +49,7 @@ class CameraSession(internal val context: Context, internal val callback: Callba
   internal var configuration: CameraConfiguration? = null
   internal val cameraProvider = ProcessCameraProvider.getInstance(context)
   internal var camera: Camera? = null
-
+  internal var audioDevice: AudioDeviceInfo? = null
   // Camera Outputs
   internal var previewOutput: Preview? = null
   internal var photoOutput: ImageCapture? = null
@@ -62,9 +68,14 @@ class CameraSession(internal val context: Context, internal val callback: Callba
   internal var isDestroyed = false
   internal val lifecycleRegistry = LifecycleRegistry(this)
   internal var recording: Recording? = null
+
+  internal var audioRecorder: MediaRecorder? = null
   internal var isRecordingCanceled = false
   internal val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
 
+  internal var recordingWithExternalAudio: Boolean = false
+  internal var audioOutputFile: java.io.File? = null
+
   // Threading
   internal val mainExecutor = ContextCompat.getMainExecutor(context)
 
@@ -165,6 +176,10 @@ class CameraSession(internal val context: Context, internal val callback: Callba
           metadataProvider.enableLocationUpdates(config.enableLocation)
         }
 
+        if(diff.audioDeviceChanged) {
+          configureAudioDevice(config,context)
+        }
+
         Log.i(
           TAG,
           "configure { ... }: Completed CameraSession Configuration! (State: ${lifecycle.currentState})"
diff --git a/package/android/src/main/java/com/mrousavy/camera/core/utils/MediaMuxerUtils.kt b/package/android/src/main/java/com/mrousavy/camera/core/utils/MediaMuxerUtils.kt
new file mode 100644
index 0000000000..719642f87a
--- /dev/null
+++ b/package/android/src/main/java/com/mrousavy/camera/core/utils/MediaMuxerUtils.kt
@@ -0,0 +1,79 @@
+package com.mrousavy.camera.core.utils
+
+import android.media.MediaCodec
+import android.media.MediaExtractor
+import android.media.MediaFormat
+import android.media.MediaMuxer
+import java.nio.ByteBuffer
+
+object MediaMuxerUtils {
+  fun muxMp4(videoPath: String, audioPath: String, outputPath: String) {
+    val videoExtractor = MediaExtractor()
+    val audioExtractor = MediaExtractor()
+    val muxer = MediaMuxer(outputPath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)
+
+    try {
+      videoExtractor.setDataSource(videoPath)
+      audioExtractor.setDataSource(audioPath)
+
+      val videoTrackIndex = selectTrack(videoExtractor, true)
+      val audioTrackIndex = selectTrack(audioExtractor, false)
+
+      if (videoTrackIndex < 0) throw IllegalStateException("No video track in $videoPath")
+      if (audioTrackIndex < 0) throw IllegalStateException("No audio track in $audioPath")
+
+      videoExtractor.selectTrack(videoTrackIndex)
+      audioExtractor.selectTrack(audioTrackIndex)
+
+      val videoFormat = videoExtractor.getTrackFormat(videoTrackIndex)
+      val audioFormat = audioExtractor.getTrackFormat(audioTrackIndex)
+
+      val muxVideoIndex = muxer.addTrack(videoFormat)
+      val muxAudioIndex = muxer.addTrack(audioFormat)
+
+      muxer.start()
+
+      copyTrack(videoExtractor, muxer, muxVideoIndex)
+      copyTrack(audioExtractor, muxer, muxAudioIndex)
+    } finally {
+      try { muxer.stop() } catch (_: Throwable) {}
+      try { muxer.release() } catch (_: Throwable) {}
+      try { videoExtractor.release() } catch (_: Throwable) {}
+      try { audioExtractor.release() } catch (_: Throwable) {}
+    }
+  }
+
+  private fun selectTrack(extractor: MediaExtractor, video: Boolean): Int {
+    for (i in 0 until extractor.trackCount) {
+      val format = extractor.getTrackFormat(i)
+      val mime = format.getString(MediaFormat.KEY_MIME) ?: continue
+      if (video && mime.startsWith("video/")) return i
+      if (!video && mime.startsWith("audio/")) return i
+    }
+    return -1
+  }
+
+  private fun copyTrack(extractor: MediaExtractor, muxer: MediaMuxer, muxTrack: Int) {
+    val currentTrack = extractor.sampleTrackIndex.takeIf { it >= 0 } ?: 0
+    val format = extractor.getTrackFormat(currentTrack)
+    val maxSize = if (format.containsKey(MediaFormat.KEY_MAX_INPUT_SIZE)) format.getInteger(MediaFormat.KEY_MAX_INPUT_SIZE) else 1024 * 1024
+    val buffer = ByteBuffer.allocateDirect(maxSize.coerceAtLeast(64 * 1024))
+    val info = MediaCodec.BufferInfo()
+    var ptsOffset = -1L
+
+    while (true) {
+      buffer.clear()
+      val sampleSize = extractor.readSampleData(buffer, 0)
+      if (sampleSize < 0) break
+      info.size = sampleSize
+      info.offset = 0
+      info.flags = extractor.sampleFlags
+      var pts = extractor.sampleTime
+      if (ptsOffset < 0 && pts >= 0) ptsOffset = pts
+      if (ptsOffset > 0 && pts >= 0) pts -= ptsOffset
+      info.presentationTimeUs = if (pts >= 0) pts else 0
+      muxer.writeSampleData(muxTrack, buffer, info)
+      extractor.advance()
+    }
+  }
+}
diff --git a/package/android/src/main/java/com/mrousavy/camera/react/AudioInputDevicesManager.kt b/package/android/src/main/java/com/mrousavy/camera/react/AudioInputDevicesManager.kt
new file mode 100644
index 0000000000..7b92745138
--- /dev/null
+++ b/package/android/src/main/java/com/mrousavy/camera/react/AudioInputDevicesManager.kt
@@ -0,0 +1,124 @@
+package com.mrousavy.camera.react
+
+import android.content.Context
+import android.util.Log
+import android.media.AudioDeviceCallback
+import android.media.AudioManager
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+import com.facebook.react.modules.core.PermissionAwareActivity
+
+private fun isMicrophoneDevice(type: Int): Boolean {
+  return when (type) {
+    android.media.AudioDeviceInfo.TYPE_BUILTIN_MIC,
+    android.media.AudioDeviceInfo.TYPE_WIRED_HEADSET,
+    android.media.AudioDeviceInfo.TYPE_BLE_HEADSET,
+    android.media.AudioDeviceInfo.TYPE_USB_DEVICE,
+    android.media.AudioDeviceInfo.TYPE_BLUETOOTH_A2DP,
+    android.media.AudioDeviceInfo.TYPE_USB_HEADSET -> true
+
+    else -> false
+  }
+}
+
+private fun deviceTypeToString(type: Int): String {
+  return when (type) {
+    android.media.AudioDeviceInfo.TYPE_BUILTIN_MIC -> "BUILTIN_MIC"
+    android.media.AudioDeviceInfo.TYPE_WIRED_HEADSET -> "WIRED_HEADSET"
+    android.media.AudioDeviceInfo.TYPE_BLE_HEADSET -> "BLUETOOTH_HEADSET"
+    android.media.AudioDeviceInfo.TYPE_USB_DEVICE -> "USB_DEVICE"
+    android.media.AudioDeviceInfo.TYPE_USB_HEADSET -> "TYPE_USB_HEADSET"
+    android.media.AudioDeviceInfo.TYPE_AUX_LINE -> "AUX_LINE"
+    else -> "UNKNOWN"
+  }
+}
+
+class AudioInputDevicesManager(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+  private val devicesChangedEventName = "AudioInputDevicesChanged"
+  private var deviceCallback: AudioDeviceCallback? = null
+  private val audioManager: AudioManager =
+    reactContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+
+  companion object {
+    private val TAG = "AudioInputDevices"
+  }
+
+  init {
+    super.initialize()
+  }
+
+  override fun getName(): String = TAG
+
+  private fun canRequestPermission(permission: String): Boolean {
+    val activity = reactApplicationContext.currentActivity as? PermissionAwareActivity
+    return activity?.shouldShowRequestPermissionRationale(permission) ?: false
+  }
+
+  private fun getDevicesJson(): ReadableArray {
+    val devices = Arguments.createArray()
+    val inputs = audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS)
+
+    for (input in inputs) {
+      if (!isMicrophoneDevice(input.type)) continue
+
+      val map = Arguments.createMap()
+      map.putString("portName", input.productName?.toString() ?: "Unknown")
+      map.putString("portType", deviceTypeToString(input.type))
+      map.putString("uid", input.id.toString())
+      devices.pushMap(map)
+    }
+
+    return devices
+  }
+
+  fun sendAvailableDevicesChangedEvent() {
+    val eventEmitter = reactContext.getJSModule(RCTDeviceEventEmitter::class.java)
+    val devices = getDevicesJson()
+
+    eventEmitter.emit(devicesChangedEventName, devices)
+  }
+
+  override fun getConstants(): MutableMap<String, Any?> {
+    val devices = getDevicesJson()
+    return mutableMapOf(
+      "availableAudioInputDevices" to devices,
+    )
+  }
+
+  @Suppress("unused", "UNUSED_PARAMETER")
+  @ReactMethod
+  fun addListener(eventName: String) {
+    if (deviceCallback == null) {
+      deviceCallback = object : AudioDeviceCallback() {
+
+        override fun onAudioDevicesAdded(addedDevices: Array<out android.media.AudioDeviceInfo>) {
+          Log.d(TAG, "onAudioDevicesAdded")
+
+          sendAvailableDevicesChangedEvent()
+        }
+        override fun onAudioDevicesRemoved(removedDevices: Array<out android.media.AudioDeviceInfo>) {
+          Log.d(TAG, "onAudioDevicesRemoved")
+          sendAvailableDevicesChangedEvent()
+        }
+      }
+      audioManager.registerAudioDeviceCallback(deviceCallback!!, null)
+      Log.d(TAG, "Audio device listener registered")
+    }
+  }
+
+  @Suppress("unused", "UNUSED_PARAMETER")
+  @ReactMethod
+  fun removeListeners(count: Int) {
+    deviceCallback?.let {
+      audioManager.unregisterAudioDeviceCallback(it)
+      deviceCallback = null
+      Log.d(TAG, "removeListeners listener ran")
+
+      Log.d(TAG, "Audio device listener unregistered")
+    }
+  }
+}
diff --git a/package/android/src/main/java/com/mrousavy/camera/react/AudioInputLevelManager.kt b/package/android/src/main/java/com/mrousavy/camera/react/AudioInputLevelManager.kt
new file mode 100644
index 0000000000..2b17d6bd6e
--- /dev/null
+++ b/package/android/src/main/java/com/mrousavy/camera/react/AudioInputLevelManager.kt
@@ -0,0 +1,181 @@
+package com.mrousavy.camera.react
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.pm.PackageManager
+import android.media.*
+import android.os.Build
+import android.util.Log
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+import com.mrousavy.camera.core.MicrophonePermissionError
+import kotlin.concurrent.thread
+import kotlin.math.log10
+import kotlin.math.sqrt
+
+class AudioInputLevelManager(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  private val eventName = "AudioInputLevelChanged"
+  private val audioManager: AudioManager =
+    reactContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+
+  private var deviceCallback: AudioDeviceCallback? = null
+  private var audioRecord: AudioRecord? = null
+  private var isMonitoring = false
+  private var monitorThread: Thread? = null
+  private var preferredAudioDevice: AudioDeviceInfo? = null
+
+  companion object {
+    private const val TAG = "AudioInputLevelManager"
+  }
+
+  internal fun checkMicrophonePermission() {
+    val status = ContextCompat.checkSelfPermission(reactContext, Manifest.permission.RECORD_AUDIO)
+    if (status != PackageManager.PERMISSION_GRANTED) throw MicrophonePermissionError()
+  }
+
+  override fun getName(): String = TAG
+
+  /**
+   * Start monitoring mic levels in a background thread.
+   */
+  @SuppressLint("MissingPermission")
+  private fun startLevelMonitoring() {
+    checkMicrophonePermission()
+    if (isMonitoring) return
+
+    val sampleRate = 44100
+    val bufferSize = AudioRecord.getMinBufferSize(
+      sampleRate,
+      AudioFormat.CHANNEL_IN_MONO,
+      AudioFormat.ENCODING_PCM_16BIT
+    )
+
+    audioRecord = AudioRecord(
+      MediaRecorder.AudioSource.MIC,
+      sampleRate,
+      AudioFormat.CHANNEL_IN_MONO,
+      AudioFormat.ENCODING_PCM_16BIT,
+      bufferSize
+    )
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      // Apply preferred input device if set
+      preferredAudioDevice?.let { device ->
+        try {
+          audioRecord?.preferredDevice = device
+        } catch (_: Throwable) {
+          // ignore, will fall back to system routing
+        }
+      }
+    }
+
+    audioRecord?.startRecording()
+    isMonitoring = true
+
+    monitorThread = thread(start = true) {
+      val buffer = ShortArray(bufferSize)
+      while (isMonitoring && audioRecord != null) {
+        val read = audioRecord!!.read(buffer, 0, buffer.size)
+        if (read > 0) {
+          // Compute RMS and dB
+          var sum: Long = 0
+          for (i in 0 until read) {
+            sum += buffer[i] * buffer[i]
+          }
+          val rms = sqrt(sum.toDouble() / read)
+          val db = if (rms > 0) 20 * log10(rms / Short.MAX_VALUE) else -160.0
+          val normalized = ((db + 160) / 160 * 100).coerceIn(0.0, 100.0)
+          sendLevelToJS(normalized)
+        }
+
+        try {
+          Thread.sleep(100) // emit every 100 ms
+        } catch (e: InterruptedException) {
+          break
+        }
+      }
+    }
+  }
+
+  private fun stopLevelMonitoring() {
+    isMonitoring = false
+    monitorThread?.interrupt()
+    monitorThread = null
+
+    audioRecord?.stop()
+    audioRecord?.release()
+    audioRecord = null
+  }
+
+  private fun sendLevelToJS(dbLevel: Double) {
+    val emitter = reactContext.getJSModule(RCTDeviceEventEmitter::class.java)
+    emitter.emit(eventName, dbLevel)
+  }
+
+  @Suppress("unused", "UNUSED_PARAMETER")
+  @ReactMethod
+  fun addListener(eventName: String) {
+    Log.d(TAG, "Listener added for $eventName")
+
+    if (deviceCallback == null) {
+      deviceCallback = object : AudioDeviceCallback() {
+        override fun onAudioDevicesAdded(addedDevices: Array<out AudioDeviceInfo>) {
+          Log.d(TAG, "Audio devices added")
+        }
+
+        override fun onAudioDevicesRemoved(removedDevices: Array<out AudioDeviceInfo>) {
+          Log.d(TAG, "Audio devices removed")
+        }
+      }
+      audioManager.registerAudioDeviceCallback(deviceCallback!!, null)
+    }
+
+    startLevelMonitoring()
+  }
+
+  @Suppress("unused", "UNUSED_PARAMETER")
+  @ReactMethod
+  fun removeListeners(count: Int) {
+    Log.d(TAG, "removeListeners called")
+
+    stopLevelMonitoring()
+
+    deviceCallback?.let {
+      audioManager.unregisterAudioDeviceCallback(it)
+      deviceCallback = null
+    }
+  }
+
+  /**
+   * Sets the preferred audio input device by its UID (AudioDeviceInfo.id as String).
+   * If monitoring is already active, it will be restarted to apply the change.
+   */
+  @ReactMethod
+  fun setPreferredAudioInputDevice(uid: String?) {
+    if (uid==null) {
+      preferredAudioDevice = null
+      audioRecord?.preferredDevice = null
+      return
+    }
+
+    val inputs = audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS)
+    val newDevice = uid?.let { idStr ->
+      inputs.firstOrNull { it.id.toString() == idStr }
+    }
+
+    preferredAudioDevice = newDevice
+
+    if (isMonitoring) {
+      // Recreate AudioRecord to ensure routing applies
+      stopLevelMonitoring()
+      startLevelMonitoring()
+    }
+  }
+}
+
diff --git a/package/android/src/main/java/com/mrousavy/camera/react/CameraPackage.kt b/package/android/src/main/java/com/mrousavy/camera/react/CameraPackage.kt
index ca2e06c05d..25006f7828 100644
--- a/package/android/src/main/java/com/mrousavy/camera/react/CameraPackage.kt
+++ b/package/android/src/main/java/com/mrousavy/camera/react/CameraPackage.kt
@@ -9,7 +9,9 @@ class CameraPackage : ReactPackage {
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
     listOf(
       CameraViewModule(reactContext),
-      CameraDevicesManager(reactContext)
+      CameraDevicesManager(reactContext),
+      AudioInputDevicesManager(reactContext),
+      AudioInputLevelManager(reactContext),
     )
 
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> = listOf(CameraViewManager())
diff --git a/package/android/src/main/java/com/mrousavy/camera/react/CameraView.kt b/package/android/src/main/java/com/mrousavy/camera/react/CameraView.kt
index 64a751eaab..31f411fdb0 100644
--- a/package/android/src/main/java/com/mrousavy/camera/react/CameraView.kt
+++ b/package/android/src/main/java/com/mrousavy/camera/react/CameraView.kt
@@ -51,6 +51,7 @@ class CameraView(context: Context) :
   // react properties
   // props that require reconfiguring
   var cameraId: String? = null
+  var audioInputDeviceUid: String? = null
   var enableDepthData = false
   var enablePortraitEffectsMatteDelivery = false
   var isMirrored = false
@@ -235,6 +236,9 @@ class CameraView(context: Context) :
 
         // isActive
         config.isActive = this@CameraView.isActive
+
+        // Input Audio Device
+        config.audioInputDeviceUid = audioInputDeviceUid
       }
     }
   }
diff --git a/package/android/src/main/java/com/mrousavy/camera/react/CameraViewManager.kt b/package/android/src/main/java/com/mrousavy/camera/react/CameraViewManager.kt
index cc20b4086c..24b9d8fc73 100644
--- a/package/android/src/main/java/com/mrousavy/camera/react/CameraViewManager.kt
+++ b/package/android/src/main/java/com/mrousavy/camera/react/CameraViewManager.kt
@@ -55,6 +55,11 @@ class CameraViewManager : ViewGroupManager<CameraView>() {
     view.cameraId = cameraId
   }
 
+  @ReactProp(name = "audioInputDeviceUid")
+  fun setAudioInputDeviceUid(view: CameraView, audioInputDeviceUid: String) {
+    view.audioInputDeviceUid = audioInputDeviceUid
+  }
+
   @ReactProp(name = "isMirrored")
   fun setIsMirrored(view: CameraView, isMirrored: Boolean) {
     view.isMirrored = isMirrored
diff --git a/package/ios/Core/CameraConfiguration.swift b/package/ios/Core/CameraConfiguration.swift
index a4b94dd377..0fecb5c79c 100644
--- a/package/ios/Core/CameraConfiguration.swift
+++ b/package/ios/Core/CameraConfiguration.swift
@@ -16,6 +16,9 @@ final class CameraConfiguration {
 
   // Input
   var cameraId: String?
+  var audioInputDeviceUid: String?
+
+    
 
   // Outputs
   var photo: OutputConfiguration<Photo> = .disabled
@@ -57,6 +60,7 @@ final class CameraConfiguration {
     if let other {
       // copy over all values
       cameraId = other.cameraId
+      audioInputDeviceUid  = other.audioInputDeviceUid
       photo = other.photo
       video = other.video
       codeScanner = other.codeScanner
@@ -83,7 +87,7 @@ final class CameraConfiguration {
   /**
    Throw this to abort calls to configure { ... } and apply no changes.
    */
-  @frozen
+    
   enum AbortThrow: Error {
     case abort
   }
@@ -101,6 +105,7 @@ final class CameraConfiguration {
 
     let audioSessionChanged: Bool
     let locationChanged: Bool
+    
 
     /**
      Returns `true` when props that affect the AVCaptureSession configuration (i.e. props that require beginConfiguration()) have changed.
@@ -141,14 +146,15 @@ final class CameraConfiguration {
       exposureChanged = inputChanged || left?.exposure != right.exposure
 
       // audio session
-      audioSessionChanged = left?.audio != right.audio
+      audioSessionChanged = left?.audio != right.audio || left?.audioInputDeviceUid != right.audioInputDeviceUid
 
       // location
       locationChanged = left?.enableLocation != right.enableLocation
+        
     }
   }
 
-  @frozen
+    
   enum OutputConfiguration<T: Equatable>: Equatable {
     case disabled
     case enabled(config: T)
diff --git a/package/ios/Core/CameraSession+Audio.swift b/package/ios/Core/CameraSession+Audio.swift
index 3d67c8c6bc..8810688dbf 100644
--- a/package/ios/Core/CameraSession+Audio.swift
+++ b/package/ios/Core/CameraSession+Audio.swift
@@ -10,25 +10,17 @@ import AVFoundation
 import Foundation
 
 extension CameraSession {
+   
   /**
    Configures the Audio session and activates it. If the session was active it will shortly be deactivated before configuration.
 
    The Audio Session will be configured to allow background music, haptics (vibrations) and system sound playback while recording.
    Background audio is allowed to play on speakers or bluetooth speakers.
    */
-  final func activateAudioSession() throws {
+    final func activateAudioSession() throws {
     VisionLogger.log(level: .info, message: "Activating Audio Session...")
 
     do {
-      let audioSession = AVAudioSession.sharedInstance()
-
-      try audioSession.updateCategory(AVAudioSession.Category.playAndRecord,
-                                      mode: .videoRecording,
-                                      options: [.mixWithOthers,
-                                                .allowBluetoothA2DP,
-                                                .defaultToSpeaker,
-                                                .allowAirPlay])
-
       if #available(iOS 14.5, *) {
         // prevents the audio session from being interrupted by a phone call
         try audioSession.setPrefersNoInterruptionsFromSystemAlerts(true)
@@ -51,10 +43,9 @@ extension CameraSession {
       }
     }
   }
-
+    
   final func deactivateAudioSession() {
     VisionLogger.log(level: .info, message: "Deactivating Audio Session...")
-
     audioCaptureSession.stopRunning()
     VisionLogger.log(level: .info, message: "Audio Session deactivated!")
   }
@@ -84,7 +75,7 @@ extension CameraSession {
           CameraQueues.audioQueue.async {
             VisionLogger.log(level: .info, message: "Resuming interrupted Audio Session...")
             // restart audio session because interruption is over
-            try? self.activateAudioSession()
+              try? self.activateAudioSession()
           }
         }
       } else {
@@ -94,4 +85,70 @@ extension CameraSession {
       ()
     }
   }
+    
+    func setAudioConfig () {
+        do {
+            try audioSession.updateCategory(AVAudioSession.Category.playAndRecord,
+                                    mode: .videoRecording,
+                                    options: [.mixWithOthers,
+                                              .allowBluetoothA2DP,
+                                              .allowBluetooth,
+                                              .defaultToSpeaker,
+                                              .allowAirPlay])}
+        catch let error as NSError {
+          VisionLogger.log(level: .error, message: "Failed to update audio category! Error \(error.code): \(error.description)")
+          }
+    }
+    // Activates AvAudioSession
+    func enableAudioSession () {
+        do {
+            try audioSession.setActive(true)
+        }
+        catch let error as NSError {
+          VisionLogger.log(level: .error, message: "Failed to activate audio session! Error \(error.code): \(error.description)")
+          }
+    }
+    
+    // Deactivates AvAudioSession
+    func disableAudioSession () {
+        do {
+            try audioSession.setActive(false)
+        }
+        catch let error as NSError {
+          VisionLogger.log(level: .error, message: "Failed to deactivate audio session! Error \(error.code): \(error.description)")
+          }
+    }
+    // Gets the preferred audio input my comparing input device uids
+    func getPreferredAudioInput() -> AVAudioSessionPortDescription? {
+       guard let availableInputs = audioSession.availableInputs else {
+           VisionLogger.log(level: .error, message: "No available inputs detected")
+           return nil
+       }
+      
+        if configuration?.audioInputDeviceUid == nil {
+            VisionLogger.log(level: .error, message: "No audio input uid specificed, reverting to first/default input")
+            return availableInputs.first
+       }
+
+        return availableInputs.first(where: { $0.uid == configuration?.audioInputDeviceUid})
+   }
+    
+    // Sets the preferred audio input device by the user
+    func setPreferredAudioInput() {
+        guard let preferredInput = getPreferredAudioInput() else {
+            return
+        }
+        disableAudioSession()
+        do {
+            try audioSession.setPreferredInput(preferredInput)
+            enableAudioSession()
+        } catch {
+            VisionLogger.log(level: .error, message: "Error setting preferred audio input: \(error.localizedDescription)")
+        }
+    }
+    
+    
 }
+
+
+
diff --git a/package/ios/Core/CameraSession+Configuration.swift b/package/ios/Core/CameraSession+Configuration.swift
index ecd2a94daf..1491939124 100644
--- a/package/ios/Core/CameraSession+Configuration.swift
+++ b/package/ios/Core/CameraSession+Configuration.swift
@@ -365,6 +365,7 @@ extension CameraSession {
     // Audio Input (Microphone)
     if enableAudio {
       VisionLogger.log(level: .info, message: "Adding Audio input...")
+        
       guard let microphone = AVCaptureDevice.default(for: .audio) else {
         throw CameraError.device(.microphoneUnavailable)
       }
diff --git a/package/ios/Core/CameraSession+Video.swift b/package/ios/Core/CameraSession+Video.swift
index 8e57710f24..2a5cbddce1 100644
--- a/package/ios/Core/CameraSession+Video.swift
+++ b/package/ios/Core/CameraSession+Video.swift
@@ -107,7 +107,7 @@ extension CameraSession {
           // Activate Audio Session asynchronously
           CameraQueues.audioQueue.async {
             do {
-              try self.activateAudioSession()
+                try self.activateAudioSession()
             } catch {
               self.onConfigureError(error)
             }
diff --git a/package/ios/Core/CameraSession.swift b/package/ios/Core/CameraSession.swift
index 10b0f3399c..8df41d41e8 100644
--- a/package/ios/Core/CameraSession.swift
+++ b/package/ios/Core/CameraSession.swift
@@ -14,319 +14,327 @@ import Foundation
  All changes to the session have to be controlled via the `configure` function.
  */
 final class CameraSession: NSObject, AVCaptureVideoDataOutputSampleBufferDelegate, AVCaptureAudioDataOutputSampleBufferDelegate {
-  // Configuration
-  private var isInitialized = false
-  var configuration: CameraConfiguration?
-  var currentConfigureCall: DispatchTime = .now()
-  // Capture Session
-  let captureSession = AVCaptureSession()
-  let audioCaptureSession = AVCaptureSession()
-  // Inputs & Outputs
-  var videoDeviceInput: AVCaptureDeviceInput?
-  var audioDeviceInput: AVCaptureDeviceInput?
-  var photoOutput: AVCapturePhotoOutput?
-  var videoOutput: AVCaptureVideoDataOutput?
-  var audioOutput: AVCaptureAudioDataOutput?
-  var codeScannerOutput: AVCaptureMetadataOutput?
-  // State
-  var metadataProvider = MetadataProvider()
-  var recordingSession: RecordingSession?
-  var didCancelRecording = false
-  var orientationManager = OrientationManager()
-
-  // Callbacks
-  weak var delegate: CameraSessionDelegate?
-
-  // Public accessors
-  var maxZoom: Double {
-    if let device = videoDeviceInput?.device {
-      return device.activeFormat.videoMaxZoomFactor
+    // Configuration
+    private var isInitialized = false
+    var configuration: CameraConfiguration?
+    var currentConfigureCall: DispatchTime = .now()
+    // Capture Session
+    let captureSession = AVCaptureSession()
+    let audioCaptureSession = AVCaptureSession()
+    let audioSession = AVAudioSession.sharedInstance()
+    // Inputs & Outputs
+    var videoDeviceInput: AVCaptureDeviceInput?
+    var audioDeviceInput: AVCaptureDeviceInput?
+    var photoOutput: AVCapturePhotoOutput?
+    var videoOutput: AVCaptureVideoDataOutput?
+    var audioOutput: AVCaptureAudioDataOutput?
+    var codeScannerOutput: AVCaptureMetadataOutput?
+    // State
+    var metadataProvider = MetadataProvider()
+    var recordingSession: RecordingSession?
+    var didCancelRecording = false
+    var orientationManager = OrientationManager()
+    
+    // Callbacks
+    weak var delegate: CameraSessionDelegate?
+    
+    // Public accessors
+    var maxZoom: Double {
+        if let device = videoDeviceInput?.device {
+            return device.activeFormat.videoMaxZoomFactor
+        }
+        return 1.0
     }
-    return 1.0
-  }
-
-  /**
-   Create a new instance of the `CameraSession`.
-   The `onError` callback is used for any runtime errors.
-   */
-  override init() {
-    super.init()
-    NotificationCenter.default.addObserver(self,
-                                           selector: #selector(sessionRuntimeError),
-                                           name: .AVCaptureSessionRuntimeError,
-                                           object: captureSession)
-    NotificationCenter.default.addObserver(self,
-                                           selector: #selector(sessionRuntimeError),
-                                           name: .AVCaptureSessionRuntimeError,
-                                           object: audioCaptureSession)
-    NotificationCenter.default.addObserver(self,
-                                           selector: #selector(audioSessionInterrupted),
-                                           name: AVAudioSession.interruptionNotification,
-                                           object: AVAudioSession.sharedInstance)
-  }
-
-  private func initialize() {
-    if isInitialized {
-      return
+    
+    /**
+     Create a new instance of the `CameraSession`.
+     The `onError` callback is used for any runtime errors.
+     */
+    override init() {
+        super.init()
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(sessionRuntimeError),
+                                               name: .AVCaptureSessionRuntimeError,
+                                               object: captureSession)
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(sessionRuntimeError),
+                                               name: .AVCaptureSessionRuntimeError,
+                                               object: audioCaptureSession)
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(audioSessionInterrupted),
+                                               name: AVAudioSession.interruptionNotification,
+                                               object: AVAudioSession.sharedInstance)
+        // Set Audio configuration to be use by the camera
+        setAudioConfig()
     }
-    orientationManager.delegate = self
-    isInitialized = true
-  }
-
-  deinit {
-    NotificationCenter.default.removeObserver(self,
-                                              name: .AVCaptureSessionRuntimeError,
-                                              object: captureSession)
-    NotificationCenter.default.removeObserver(self,
-                                              name: .AVCaptureSessionRuntimeError,
-                                              object: audioCaptureSession)
-    NotificationCenter.default.removeObserver(self,
-                                              name: AVAudioSession.interruptionNotification,
-                                              object: AVAudioSession.sharedInstance)
-  }
-
-  /**
-   Creates a PreviewView for the current Capture Session
-   */
-  func createPreviewView(frame: CGRect) -> PreviewView {
-    return PreviewView(frame: frame, session: captureSession)
-  }
-
-  func onConfigureError(_ error: Error) {
-    if let error = error as? CameraError {
-      // It's a typed Error
-      delegate?.onError(error)
-    } else {
-      // It's any kind of unknown error
-      let cameraError = CameraError.unknown(message: error.localizedDescription)
-      delegate?.onError(cameraError)
+    
+    private func initialize() {
+        if isInitialized {
+            return
+        }
+        orientationManager.delegate = self
+        
+        isInitialized = true
     }
-  }
-
-  /**
-   Update the session configuration.
-   Any changes in here will be re-configured only if required, and under a lock (in this case, the serial cameraQueue DispatchQueue).
-   The `configuration` object is a copy of the currently active configuration that can be modified by the caller in the lambda.
-   */
-  func configure(_ lambda: @escaping (_ configuration: CameraConfiguration) throws -> Void) {
-    initialize()
-
-    VisionLogger.log(level: .info, message: "configure { ... }: Waiting for lock...")
-
-    // Set up Camera (Video) Capture Session (on camera queue, acts like a lock)
-    CameraQueues.cameraQueue.async {
-      // Let caller configure a new configuration for the Camera.
-      let config = CameraConfiguration(copyOf: self.configuration)
-      do {
-        try lambda(config)
-      } catch CameraConfiguration.AbortThrow.abort {
-        // call has been aborted and changes shall be discarded
-        return
-      } catch {
-        // another error occured, possibly while trying to parse enums
-        self.onConfigureError(error)
-        return
-      }
-      let difference = CameraConfiguration.Difference(between: self.configuration, and: config)
-
-      VisionLogger.log(level: .info, message: "configure { ... }: Updating CameraSession Configuration... \(difference)")
-
-      do {
-        // If needed, configure the AVCaptureSession (inputs, outputs)
-        if difference.isSessionConfigurationDirty {
-          self.captureSession.beginConfiguration()
-
-          // 1. Update input device
-          if difference.inputChanged {
-            try self.configureDevice(configuration: config)
-          }
-          // 2. Update outputs
-          if difference.outputsChanged {
-            try self.configureOutputs(configuration: config)
-          }
-          // 3. Update Video Stabilization
-          if difference.videoStabilizationChanged {
-            self.configureVideoStabilization(configuration: config)
-          }
-          // 4. Update target output orientation
-          if difference.orientationChanged {
-            self.orientationManager.setTargetOutputOrientation(config.outputOrientation)
-          }
+    
+    deinit {
+        NotificationCenter.default.removeObserver(self,
+                                                  name: .AVCaptureSessionRuntimeError,
+                                                  object: captureSession)
+        NotificationCenter.default.removeObserver(self,
+                                                  name: .AVCaptureSessionRuntimeError,
+                                                  object: audioCaptureSession)
+        NotificationCenter.default.removeObserver(self,
+                                                  name: AVAudioSession.interruptionNotification,
+                                                  object: AVAudioSession.sharedInstance)
+        
+    }
+    
+    /**
+     Creates a PreviewView for the current Capture Session
+     */
+    func createPreviewView(frame: CGRect) -> PreviewView {
+        return PreviewView(frame: frame, session: captureSession)
+    }
+    
+    func onConfigureError(_ error: Error) {
+        if let error = error as? CameraError {
+            // It's a typed Error
+            delegate?.onError(error)
+        } else {
+            // It's any kind of unknown error
+            let cameraError = CameraError.unknown(message: error.localizedDescription)
+            delegate?.onError(cameraError)
         }
-
-        guard let device = self.videoDeviceInput?.device else {
-          throw CameraError.device(.noDevice)
+    }
+    
+    /**
+     Update the session configuration.
+     Any changes in here will be re-configured only if required, and under a lock (in this case, the serial cameraQueue DispatchQueue).
+     The `configuration` object is a copy of the currently active configuration that can be modified by the caller in the lambda.
+     */
+    func configure(_ lambda: @escaping (_ configuration: CameraConfiguration) throws -> Void) {
+        initialize()
+        
+        VisionLogger.log(level: .info, message: "configure { ... }: Waiting for lock...")
+        
+        // Set up Camera (Video) Capture Session (on camera queue, acts like a lock)
+        CameraQueues.cameraQueue.async {
+            // Let caller configure a new configuration for the Camera.
+            let config = CameraConfiguration(copyOf: self.configuration)
+            do {
+                try lambda(config)
+            } catch CameraConfiguration.AbortThrow.abort {
+                // call has been aborted and changes shall be discarded
+                return
+            } catch {
+                // another error occured, possibly while trying to parse enums
+                self.onConfigureError(error)
+                return
+            }
+            let difference = CameraConfiguration.Difference(between: self.configuration, and: config)
+            
+            VisionLogger.log(level: .info, message: "configure { ... }: Updating CameraSession Configuration... \(difference)")
+            
+            do {
+                // If needed, configure the AVCaptureSession (inputs, outputs)
+                if difference.isSessionConfigurationDirty {
+                    self.captureSession.beginConfiguration()
+                    
+                    // 1. Update input device
+                    if difference.inputChanged {
+                        try self.configureDevice(configuration: config)
+                    }
+                    // 2. Update outputs
+                    if difference.outputsChanged {
+                        try self.configureOutputs(configuration: config)
+                    }
+                    // 3. Update Video Stabilization
+                    if difference.videoStabilizationChanged {
+                        self.configureVideoStabilization(configuration: config)
+                    }
+                    // 4. Update target output orientation
+                    if difference.orientationChanged {
+                        self.orientationManager.setTargetOutputOrientation(config.outputOrientation)
+                    }
+                }
+                
+                guard let device = self.videoDeviceInput?.device else {
+                    throw CameraError.device(.noDevice)
+                }
+                
+                // If needed, configure the AVCaptureDevice (format, zoom, low-light-boost, ..)
+                if difference.isDeviceConfigurationDirty {
+                    try device.lockForConfiguration()
+                    defer {
+                        device.unlockForConfiguration()
+                    }
+                    
+                    // 5. Configure format
+                    if difference.formatChanged {
+                        try self.configureFormat(configuration: config, device: device)
+                    }
+                    // 6. After step 2. and 4., we also need to configure some output properties that depend on format.
+                    //    This needs to be done AFTER we updated the `format`, as this controls the supported properties.
+                    if difference.outputsChanged || difference.formatChanged {
+                        self.configureVideoOutputFormat(configuration: config)
+                        self.configurePhotoOutputFormat(configuration: config)
+                    }
+                    // 7. Configure side-props (fps, lowLightBoost)
+                    if difference.sidePropsChanged {
+                        try self.configureSideProps(configuration: config, device: device)
+                    }
+                    // 8. Configure zoom
+                    if difference.zoomChanged {
+                        self.configureZoom(configuration: config, device: device)
+                    }
+                    // 9. Configure exposure bias
+                    if difference.exposureChanged {
+                        self.configureExposure(configuration: config, device: device)
+                    }
+                }
+                
+                if difference.isSessionConfigurationDirty {
+                    // We commit the session config updates AFTER the device config,
+                    // that way we can also batch those changes into one update instead of doing two updates.
+                    self.captureSession.commitConfiguration()
+                }
+                
+                // 10. Start or stop the session if needed
+                self.checkIsActive(configuration: config)
+                
+                // 11. Enable or disable the Torch if needed (requires session to be running)
+                if difference.torchChanged {
+                    try device.lockForConfiguration()
+                    defer {
+                        device.unlockForConfiguration()
+                    }
+                    try self.configureTorch(configuration: config, device: device)
+                }
+                
+                // After configuring, set this to the new configuration.
+                self.configuration = config
+            } catch {
+                self.onConfigureError(error)
+            }
+            
+            // Set up Audio Capture Session (on audio queue)
+            if difference.audioSessionChanged {
+                CameraQueues.audioQueue.async {
+                    do {
+                        // Set the preferred input device on props change
+                        self.setPreferredAudioInput()
+                        
+                        // Lock Capture Session for configuration
+                        VisionLogger.log(level: .info, message: "Beginning AudioSession configuration...")
+                        self.audioCaptureSession.beginConfiguration()
+                        
+                        try self.configureAudioSession(configuration: config)
+                        
+                        // Unlock Capture Session again and submit configuration to Hardware
+                        self.audioCaptureSession.commitConfiguration()
+                        VisionLogger.log(level: .info, message: "Committed AudioSession configuration!")
+                    } catch {
+                        self.onConfigureError(error)
+                    }
+                }
+            }
+            
+            // Set up Location streaming (on location queue)
+            if difference.locationChanged {
+                CameraQueues.locationQueue.async {
+                    do {
+                        VisionLogger.log(level: .info, message: "Beginning Location Output configuration...")
+                        try self.configureLocationOutput(configuration: config)
+                        VisionLogger.log(level: .info, message: "Finished Location Output configuration!")
+                    } catch {
+                        self.onConfigureError(error)
+                    }
+                }
+            }
         }
-
-        // If needed, configure the AVCaptureDevice (format, zoom, low-light-boost, ..)
-        if difference.isDeviceConfigurationDirty {
-          try device.lockForConfiguration()
-          defer {
-            device.unlockForConfiguration()
-          }
-
-          // 5. Configure format
-          if difference.formatChanged {
-            try self.configureFormat(configuration: config, device: device)
-          }
-          // 6. After step 2. and 4., we also need to configure some output properties that depend on format.
-          //    This needs to be done AFTER we updated the `format`, as this controls the supported properties.
-          if difference.outputsChanged || difference.formatChanged {
-            self.configureVideoOutputFormat(configuration: config)
-            self.configurePhotoOutputFormat(configuration: config)
-          }
-          // 7. Configure side-props (fps, lowLightBoost)
-          if difference.sidePropsChanged {
-            try self.configureSideProps(configuration: config, device: device)
-          }
-          // 8. Configure zoom
-          if difference.zoomChanged {
-            self.configureZoom(configuration: config, device: device)
-          }
-          // 9. Configure exposure bias
-          if difference.exposureChanged {
-            self.configureExposure(configuration: config, device: device)
-          }
+    }
+    
+    /**
+     Starts or stops the CaptureSession if needed (`isActive`)
+     */
+    private func checkIsActive(configuration: CameraConfiguration) {
+        if configuration.isActive == captureSession.isRunning {
+            return
         }
-
-        if difference.isSessionConfigurationDirty {
-          // We commit the session config updates AFTER the device config,
-          // that way we can also batch those changes into one update instead of doing two updates.
-          self.captureSession.commitConfiguration()
+        
+        // Start/Stop session
+        if configuration.isActive {
+            captureSession.startRunning()
+            delegate?.onCameraStarted()
+        } else {
+            captureSession.stopRunning()
+            delegate?.onCameraStopped()
         }
-
-        // 10. Start or stop the session if needed
-        self.checkIsActive(configuration: config)
-
-        // 11. Enable or disable the Torch if needed (requires session to be running)
-        if difference.torchChanged {
-          try device.lockForConfiguration()
-          defer {
-            device.unlockForConfiguration()
-          }
-          try self.configureTorch(configuration: config, device: device)
+    }
+    
+    public final func captureOutput(_ captureOutput: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
+        switch captureOutput {
+        case is AVCaptureVideoDataOutput:
+            onVideoFrame(sampleBuffer: sampleBuffer, orientation: connection.orientation, isMirrored: connection.isVideoMirrored)
+        case is AVCaptureAudioDataOutput:
+            onAudioFrame(sampleBuffer: sampleBuffer)
+        default:
+            break
         }
-
-        // After configuring, set this to the new configuration.
-        self.configuration = config
-      } catch {
-        self.onConfigureError(error)
-      }
-
-      // Set up Audio Capture Session (on audio queue)
-      if difference.audioSessionChanged {
-        CameraQueues.audioQueue.async {
-          do {
-            // Lock Capture Session for configuration
-            VisionLogger.log(level: .info, message: "Beginning AudioSession configuration...")
-            self.audioCaptureSession.beginConfiguration()
-
-            try self.configureAudioSession(configuration: config)
-
-            // Unlock Capture Session again and submit configuration to Hardware
-            self.audioCaptureSession.commitConfiguration()
-            VisionLogger.log(level: .info, message: "Committed AudioSession configuration!")
-          } catch {
-            self.onConfigureError(error)
-          }
+    }
+    
+    private final func onVideoFrame(sampleBuffer: CMSampleBuffer, orientation: Orientation, isMirrored: Bool) {
+        if let recordingSession {
+            do {
+                // Write the Video Buffer to the .mov/.mp4 file
+                try recordingSession.append(buffer: sampleBuffer, ofType: .video)
+            } catch let error as CameraError {
+                delegate?.onError(error)
+            } catch {
+                delegate?.onError(.capture(.unknown(message: error.localizedDescription)))
+            }
         }
-      }
-
-      // Set up Location streaming (on location queue)
-      if difference.locationChanged {
-        CameraQueues.locationQueue.async {
-          do {
-            VisionLogger.log(level: .info, message: "Beginning Location Output configuration...")
-            try self.configureLocationOutput(configuration: config)
-            VisionLogger.log(level: .info, message: "Finished Location Output configuration!")
-          } catch {
-            self.onConfigureError(error)
-          }
+        
+        if let delegate {
+            // Call Frame Processor (delegate) for every Video Frame
+            delegate.onFrame(sampleBuffer: sampleBuffer, orientation: orientation, isMirrored: isMirrored)
         }
-      }
     }
-  }
-
-  /**
-   Starts or stops the CaptureSession if needed (`isActive`)
-   */
-  private func checkIsActive(configuration: CameraConfiguration) {
-    if configuration.isActive == captureSession.isRunning {
-      return
-    }
-
-    // Start/Stop session
-    if configuration.isActive {
-      captureSession.startRunning()
-      delegate?.onCameraStarted()
-    } else {
-      captureSession.stopRunning()
-      delegate?.onCameraStopped()
-    }
-  }
-
-  public final func captureOutput(_ captureOutput: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
-    switch captureOutput {
-    case is AVCaptureVideoDataOutput:
-      onVideoFrame(sampleBuffer: sampleBuffer, orientation: connection.orientation, isMirrored: connection.isVideoMirrored)
-    case is AVCaptureAudioDataOutput:
-      onAudioFrame(sampleBuffer: sampleBuffer)
-    default:
-      break
-    }
-  }
-
-  private final func onVideoFrame(sampleBuffer: CMSampleBuffer, orientation: Orientation, isMirrored: Bool) {
-    if let recordingSession {
-      do {
-        // Write the Video Buffer to the .mov/.mp4 file
-        try recordingSession.append(buffer: sampleBuffer, ofType: .video)
-      } catch let error as CameraError {
-        delegate?.onError(error)
-      } catch {
-        delegate?.onError(.capture(.unknown(message: error.localizedDescription)))
-      }
-    }
-
-    if let delegate {
-      // Call Frame Processor (delegate) for every Video Frame
-      delegate.onFrame(sampleBuffer: sampleBuffer, orientation: orientation, isMirrored: isMirrored)
-    }
-  }
-
-  private final func onAudioFrame(sampleBuffer: CMSampleBuffer) {
-    if let recordingSession {
-      do {
-        // Synchronize the Audio Buffer with the Video Session's time because it's two separate
-        // AVCaptureSessions, then write it to the .mov/.mp4 file
-        audioCaptureSession.synchronizeBuffer(sampleBuffer, toSession: captureSession)
-        try recordingSession.append(buffer: sampleBuffer, ofType: .audio)
-      } catch let error as CameraError {
-        delegate?.onError(error)
-      } catch {
-        delegate?.onError(.capture(.unknown(message: error.localizedDescription)))
-      }
-    }
-  }
-
-  // pragma MARK: Notifications
-
-  @objc
-  func sessionRuntimeError(notification: Notification) {
-    VisionLogger.log(level: .error, message: "Unexpected Camera Runtime Error occured!")
-    guard let error = notification.userInfo?[AVCaptureSessionErrorKey] as? AVError else {
-      return
+    
+    private final func onAudioFrame(sampleBuffer: CMSampleBuffer) {
+        if let recordingSession {
+            do {
+                // Synchronize the Audio Buffer with the Video Session's time because it's two separate
+                // AVCaptureSessions, then write it to the .mov/.mp4 file
+                audioCaptureSession.synchronizeBuffer(sampleBuffer, toSession: captureSession)
+                try recordingSession.append(buffer: sampleBuffer, ofType: .audio)
+            } catch let error as CameraError {
+                delegate?.onError(error)
+            } catch {
+                delegate?.onError(.capture(.unknown(message: error.localizedDescription)))
+            }
+        }
     }
-
-    // Notify consumer about runtime error
-    delegate?.onError(.unknown(message: error._nsError.description, cause: error._nsError))
-
-    let shouldRestart = configuration?.isActive == true
-    if shouldRestart {
-      // restart capture session after an error occured
-      CameraQueues.cameraQueue.async {
-        self.captureSession.startRunning()
-      }
+    
+    // pragma MARK: Notifications
+    
+    @objc
+    func sessionRuntimeError(notification: Notification) {
+        VisionLogger.log(level: .error, message: "Unexpected Camera Runtime Error occured!")
+        guard let error = notification.userInfo?[AVCaptureSessionErrorKey] as? AVError else {
+            return
+        }
+        
+        // Notify consumer about runtime error
+        delegate?.onError(.unknown(message: error._nsError.description, cause: error._nsError))
+        
+        let shouldRestart = configuration?.isActive == true
+        if shouldRestart {
+            // restart capture session after an error occured
+            CameraQueues.cameraQueue.async {
+                self.captureSession.startRunning()
+            }
+        }
     }
-  }
 }
diff --git a/package/ios/Core/Types/RecordVideoOptions.swift b/package/ios/Core/Types/RecordVideoOptions.swift
index d12e05eb79..ae40728fe4 100644
--- a/package/ios/Core/Types/RecordVideoOptions.swift
+++ b/package/ios/Core/Types/RecordVideoOptions.swift
@@ -14,6 +14,7 @@ struct RecordVideoOptions {
   var flash: Torch = .off
   var codec: AVVideoCodecType?
   var path: URL
+  
   /**
    * Full Bit-Rate override for the Video Encoder, in Megabits per second (Mbps)
    */
diff --git a/package/ios/React/AudioInputDevicesManager.m b/package/ios/React/AudioInputDevicesManager.m
new file mode 100644
index 0000000000..6cd6c615cb
--- /dev/null
+++ b/package/ios/React/AudioInputDevicesManager.m
@@ -0,0 +1,14 @@
+//
+//  AudioInputManager.m
+//  VisionCamera
+//
+//  Created by SnowFox (Y.O) on 19.08.25.
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTUtils.h>
+
+@interface RCT_EXTERN_REMAP_MODULE (AudioInputDevices, AudioInputDevicesManager, RCTEventEmitter)
+
+@end
diff --git a/package/ios/React/AudioInputDevicesManager.swift b/package/ios/React/AudioInputDevicesManager.swift
new file mode 100644
index 0000000000..a0e1130443
--- /dev/null
+++ b/package/ios/React/AudioInputDevicesManager.swift
@@ -0,0 +1,70 @@
+//
+//  AudioInputManager.swift
+//  VisionCamera
+//
+//  Created by SnowFox (Y.O) on 19.08.25.
+//
+
+import AVFoundation
+import Foundation
+
+@objc(AudioInputDevicesManager)
+final class AudioInputDevicesManager: RCTEventEmitter {
+    private let audioSession = AVAudioSession.sharedInstance()
+    private let notificationCetner = NotificationCenter.default
+    private var observer: NSKeyValueObservation?
+    private let devicesChangedEventName = "AudioInputDevicesChanged"
+    
+    override init(){
+        super.init()
+    }
+    
+    override func invalidate() {
+        notificationCetner.removeObserver(self)
+    }
+    
+    override func supportedEvents() -> [String]! {
+        return [devicesChangedEventName]
+    }
+    
+    override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+    
+    override func constantsToExport() -> [AnyHashable: Any]! {
+        let devices = getDevicesJson()
+        
+        VisionLogger.log(level: .info, message: "Found \(devices.count) initial Audio Input Devices.")
+        
+        return [
+            "availableAudioInputDevices": devices,
+        ]
+    }
+    
+    @objc private func handleAvailableInputsChanged(_ notification: Notification) {
+        let devices = getDevicesJson()
+        VisionLogger.log(level: .info, message: "Audio Input Devices changed - found \(devices.count) Audio Devices.")
+        self.sendEvent(withName: self.devicesChangedEventName, body: devices)
+    }
+    
+    private func getDevicesJson () ->  [[String: Any]] {
+        // Return initially available devices
+        return audioSession.availableInputs?.map { input in
+            return [
+                "portName": input.portName,
+                "portType": input.portType.rawValue,
+                "uid": input.uid,
+            ]
+        } ?? []
+    }
+    
+    override func startObserving() {
+        notificationCetner.addObserver(self, selector:#selector(handleAvailableInputsChanged(_:)) ,  name: AVAudioSession.routeChangeNotification, object: audioSession)
+        
+    }
+    
+    override func stopObserving() {
+        notificationCetner.removeObserver(self)
+    }
+    
+}
diff --git a/package/ios/React/AudioInputLevelManager.m b/package/ios/React/AudioInputLevelManager.m
new file mode 100644
index 0000000000..af934bd50e
--- /dev/null
+++ b/package/ios/React/AudioInputLevelManager.m
@@ -0,0 +1,14 @@
+//
+//  AudioInputLevelManager.m
+//  VisionCamera
+//
+//  Created by SnowFox (Y.O) on 24.08.25.
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTUtils.h>
+
+@interface RCT_EXTERN_REMAP_MODULE (AudioInputLevel, AudioInputLevelManager, RCTEventEmitter)
+
+@end
diff --git a/package/ios/React/AudioInputLevelManager.swift b/package/ios/React/AudioInputLevelManager.swift
new file mode 100644
index 0000000000..a1df68f551
--- /dev/null
+++ b/package/ios/React/AudioInputLevelManager.swift
@@ -0,0 +1,128 @@
+//
+//  AudioInputLevelManager.swift
+//  VisionCamera
+//
+//  Created by SnowFox (Y.O) on 24.08.25.
+//
+
+import Foundation
+import AVFAudio
+
+
+@objc(AudioInputLevelManager)
+final class AudioInputLevelManager: RCTEventEmitter {
+    private let audioSession = AVAudioSession.sharedInstance()
+    private let notificationCetner = NotificationCenter.default
+    private var audioEngine = AVAudioEngine()
+    private let audioLevelChangedEventName = "AudioInputLevelChanged"
+    
+    override init(){
+        super.init()
+    }
+    
+    override func invalidate() {
+        notificationCetner.removeObserver(self)
+        self.removeInputNode()
+    }
+    
+    override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+    
+    override func supportedEvents() -> [String]! {
+        return [audioLevelChangedEventName]
+    }
+    
+    private func startInputNode () {
+        // Update audio engine
+        audioEngine = AVAudioEngine()
+        let inputNode = audioEngine.inputNode
+        let format = inputNode.inputFormat(forBus: 0)
+        // Below guard prevents errors that might happen when installing tap
+        if (format.sampleRate == 0) {
+            return
+        }
+        
+        inputNode.installTap(onBus: 0, bufferSize: 1024, format: format) { buffer, _ in
+            let level = self.getSoundLevel(buffer: buffer)
+            self.sendEvent(withName: self.audioLevelChangedEventName, body: level)
+        }
+        // Start audio engine and send events to the listener
+        try? audioEngine.start()
+    }
+    
+    @objc private func restartInputNode(_ notification: Notification) {
+        guard let userInfo = notification.userInfo,
+              let reasonValue = userInfo[AVAudioSessionRouteChangeReasonKey] as? UInt,
+              let reason = AVAudioSession.RouteChangeReason(rawValue: reasonValue) else {
+            return
+        }
+        
+        switch reason {
+        case .unknown:
+            return
+        default:
+            self.startInputNode()
+        }
+        
+    }
+    
+    private func removeInputNode() {
+        audioEngine.stop()
+        audioEngine.inputNode.removeTap(onBus: 0)
+    }
+    
+    private func getSoundLevel(buffer: AVAudioPCMBuffer) -> Float {
+        guard let channelData = buffer.floatChannelData else { return 0 }
+        let channelDataArray = Array(UnsafeBufferPointer(start: channelData[0], count: Int(buffer.frameLength)))
+        let rms = sqrt(channelDataArray.map { $0 * $0 }.reduce(0, +) / Float(buffer.frameLength) + Float.ulpOfOne)
+        let level = 20 * log10(rms)
+        return max(level + 100, 0)
+    }
+    
+    @objc func handleInterruption(notification: Notification) {
+        guard let info = notification.userInfo,
+              let type = info[AVAudioSessionInterruptionTypeKey] as? UInt else { return }
+        
+        if type == AVAudioSession.InterruptionType.began.rawValue {
+            // pause or stop engine
+            if audioEngine.isRunning {
+                audioEngine.pause()
+                VisionLogger.log(level:.info, message:"audio engine interrupted status: paused")
+            }
+        } else if type == AVAudioSession.InterruptionType.ended.rawValue {
+            // restart engine if needed
+            try? audioEngine.start()
+            VisionLogger.log(level:.info, message: "audio engine interrupted status: started")
+            
+        }
+    }
+    
+    @objc func appMovedToBackground() {
+        if audioEngine.isRunning {
+            audioEngine.pause()
+        }
+    }
+    
+    @objc func appMovedToForeground() {
+        try? audioEngine.start()
+    }
+    
+    @objc func setPreferredAudioInputDevice(uid:String?) {
+        // this fuction is a placeholder function
+        // ios apps handle audio globally for the app, therefore
+        // this function shouldn't change preferred input here as it would change it for the whole app
+        return
+    }
+    
+    override func startObserving() {
+        notificationCetner.addObserver(self, selector:#selector(restartInputNode(_:)) ,  name: AVAudioSession.routeChangeNotification, object: audioSession)
+        notificationCetner.addObserver(self, selector: #selector(appMovedToBackground), name: UIApplication.willResignActiveNotification, object: nil)
+        notificationCetner.addObserver(self, selector: #selector(appMovedToForeground), name: UIApplication.didBecomeActiveNotification, object: nil)
+    }
+    
+    override func stopObserving() {
+        notificationCetner.removeObserver(self)
+        self.removeInputNode()
+    }
+}
diff --git a/package/ios/React/CameraView+RecordVideo.swift b/package/ios/React/CameraView+RecordVideo.swift
index 913d420efd..4fdefedcdc 100644
--- a/package/ios/React/CameraView+RecordVideo.swift
+++ b/package/ios/React/CameraView+RecordVideo.swift
@@ -19,7 +19,7 @@ extension CameraView: AVCaptureVideoDataOutputSampleBufferDelegate, AVCaptureAud
       let options = try RecordVideoOptions(fromJSValue: options,
                                            bitRateOverride: videoBitRateOverride?.doubleValue,
                                            bitRateMultiplier: videoBitRateMultiplier?.doubleValue)
-
+        
       // Start Recording with success and error callbacks
       cameraSession.startRecording(
         options: options,
diff --git a/package/ios/React/CameraView.swift b/package/ios/React/CameraView.swift
index c773975353..a67f9d8d12 100644
--- a/package/ios/React/CameraView.swift
+++ b/package/ios/React/CameraView.swift
@@ -25,6 +25,8 @@ public final class CameraView: UIView, CameraSessionDelegate, PreviewViewDelegat
 
   // props that require reconfiguring
   @objc var cameraId: NSString?
+  @objc var audioInputDeviceUid: NSString?
+
   @objc var enableDepthData = false
   @objc var enablePortraitEffectsMatteDelivery = false
   @objc var enableBufferCompression = false
@@ -183,7 +185,7 @@ public final class CameraView: UIView, CameraSessionDelegate, PreviewViewDelegat
     VisionLogger.log(level: .info, message: "Updating \(changedProps.count) props: [\(changedProps.joined(separator: ", "))]")
     let now = DispatchTime.now()
     currentConfigureCall = now
-
+   
     cameraSession.configure { [self] config in
       // Check if we're still the latest call to configure { ... }
       guard currentConfigureCall == now else {
@@ -196,7 +198,7 @@ public final class CameraView: UIView, CameraSessionDelegate, PreviewViewDelegat
       // Input Camera Device
       config.cameraId = cameraId as? String
       config.isMirrored = isMirrored
-
+        
       // Photo
       if photo {
         config.photo = .enabled(config: CameraConfiguration.Photo(qualityBalance: getPhotoQualityBalance(),
@@ -272,13 +274,16 @@ public final class CameraView: UIView, CameraSessionDelegate, PreviewViewDelegat
 
       // isActive
       config.isActive = isActive
+      
+      // Preferred audio input device uid
+      config.audioInputDeviceUid = audioInputDeviceUid as String?
     }
 
     // Store `zoom` offset for native pinch-gesture
     if changedProps.contains("zoom") {
       pinchScaleOffset = zoom.doubleValue
     }
-
+    
     // Prevent phone from going to sleep
     UIApplication.shared.isIdleTimerDisabled = isActive
   }
diff --git a/package/ios/React/CameraViewManager.m b/package/ios/React/CameraViewManager.m
index 527c9bc0fd..d39ca0f581 100644
--- a/package/ios/React/CameraViewManager.m
+++ b/package/ios/React/CameraViewManager.m
@@ -26,6 +26,7 @@ @interface RCT_EXTERN_REMAP_MODULE (CameraView, CameraViewManager, RCTViewManage
 // Camera View Properties
 RCT_EXPORT_VIEW_PROPERTY(isActive, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(cameraId, NSString);
+RCT_EXPORT_VIEW_PROPERTY(audioInputDeviceUid, NSString);
 RCT_EXPORT_VIEW_PROPERTY(enableDepthData, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(enablePortraitEffectsMatteDelivery, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(enableBufferCompression, BOOL);
diff --git a/package/src/AudioInputDevices.ts b/package/src/AudioInputDevices.ts
new file mode 100644
index 0000000000..19d663680b
--- /dev/null
+++ b/package/src/AudioInputDevices.ts
@@ -0,0 +1,27 @@
+import { NativeModules, NativeEventEmitter } from 'react-native'
+import type { AudioInputDevice } from './types/AudioInputDevice'
+
+const AudioInputDevicesManager = NativeModules.AudioInputDevices as {
+  getConstants: () => {
+    availableAudioInputDevices: AudioInputDevice[]
+  }
+}
+
+const constants = AudioInputDevicesManager.getConstants()
+
+const DEVICES_CHANGED_NAME = 'AudioInputDevicesChanged'
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const eventEmitter = new NativeEventEmitter(AudioInputDevicesManager as any)
+
+export const AudioInputDevices = {
+  /**
+   * Get the list of available input devices initially
+   */
+  getAvailableAudioInputDevices: () => constants.availableAudioInputDevices,
+  /**
+   * Listen for audio input device changes. Returns an update list of input devices.
+   */
+  addAudioInputChangedListener: (callback: (newDevices: AudioInputDevice[]) => void) => {
+    return eventEmitter.addListener(DEVICES_CHANGED_NAME, callback)
+  },
+}
diff --git a/package/src/Camera.tsx b/package/src/Camera.tsx
index afe056a761..fced373a69 100644
--- a/package/src/Camera.tsx
+++ b/package/src/Camera.tsx
@@ -616,7 +616,7 @@ export class Camera extends React.PureComponent<CameraProps, CameraState> {
   /** @internal */
   public render(): React.ReactNode {
     // We remove the big `device` object from the props because we only need to pass `cameraId` to native.
-    const { device, frameProcessor, codeScanner, enableFpsGraph, fps, videoBitRate, ...props } = this.props
+    const { device, audioInputDevice, frameProcessor, codeScanner, enableFpsGraph, fps, videoBitRate, ...props } = this.props
 
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (device == null) {
@@ -650,6 +650,7 @@ export class Camera extends React.PureComponent<CameraProps, CameraState> {
       <NativeCameraView
         {...props}
         cameraId={device.id}
+        audioInputDeviceUid={audioInputDevice?.uid}
         ref={this.ref}
         torch={torch}
         minFps={minFps}
diff --git a/package/src/NativeCameraView.ts b/package/src/NativeCameraView.ts
index b53009ce56..e6757c11d6 100644
--- a/package/src/NativeCameraView.ts
+++ b/package/src/NativeCameraView.ts
@@ -26,6 +26,7 @@ export interface PreviewOrientationChangedEvent {
 export type NativeCameraViewProps = Omit<
   CameraProps,
   | 'device'
+  | 'audioInputDevice'
   | 'onInitialized'
   | 'onError'
   | 'onShutter'
@@ -38,6 +39,7 @@ export type NativeCameraViewProps = Omit<
 > & {
   // private intermediate props
   cameraId: string
+  audioInputDeviceUid?: string
   enableFrameProcessor: boolean
   codeScannerOptions?: Omit<CodeScanner, 'onCodeScanned'>
   minFps?: number
diff --git a/package/src/hooks/useAudioInputDevices.ts b/package/src/hooks/useAudioInputDevices.ts
new file mode 100644
index 0000000000..4744bc0945
--- /dev/null
+++ b/package/src/hooks/useAudioInputDevices.ts
@@ -0,0 +1,23 @@
+import { useEffect, useState } from 'react'
+import { AudioInputDevices } from '../AudioInputDevices'
+import type { AudioInputDevice } from '../types/AudioInputDevice'
+
+/**
+ * Get the available audio input devices for the current audio session.
+ *
+ * Built in microphone is always available after permissions,
+ * while `external` devices might be plugged in or out at any point,
+ * so the result of this hook might update over time.
+ */
+export function useAudioInputDevices(): AudioInputDevice[] {
+  const [devices, setDevices] = useState(AudioInputDevices.getAvailableAudioInputDevices)
+
+  useEffect(() => {
+    const listener = AudioInputDevices.addAudioInputChangedListener((newDevices) => {
+      setDevices(newDevices)
+    })
+    return () => listener.remove()
+  }, [])
+
+  return devices
+}
diff --git a/package/src/index.ts b/package/src/index.ts
index a375739263..3d3cd7afbe 100644
--- a/package/src/index.ts
+++ b/package/src/index.ts
@@ -20,6 +20,9 @@ export * from './devices/getCameraFormat'
 export * from './devices/getCameraDevice'
 export * from './devices/Templates'
 
+// Listeners
+export * from './listeners/AudioInputLevel'
+
 // Hooks
 export * from './hooks/useCameraDevice'
 export * from './hooks/useCameraDevices'
@@ -27,7 +30,7 @@ export * from './hooks/useCameraFormat'
 export * from './hooks/useCameraPermission'
 export * from './hooks/useCodeScanner'
 export * from './hooks/useFrameProcessor'
-
+export * from './hooks/useAudioInputDevices'
 // Frame Processors
 export * from './frame-processors/runAsync'
 export * from './frame-processors/runAtTargetFps'
diff --git a/package/src/listeners/AudioInputLevel.ts b/package/src/listeners/AudioInputLevel.ts
new file mode 100644
index 0000000000..8bad7257ed
--- /dev/null
+++ b/package/src/listeners/AudioInputLevel.ts
@@ -0,0 +1,28 @@
+import { NativeModules, NativeEventEmitter } from 'react-native'
+
+type AudioInputLevelManagerType = {
+  setPreferredAudioInputDevice: (uid: string | null) => void
+}
+
+const AudioInputLevelManager = NativeModules.AudioInputLevelManager as AudioInputLevelManagerType
+const AUDIO_LEVEL_CHANGED_NAME = 'AudioInputLevelChanged'
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const eventEmitter = new NativeEventEmitter(NativeModules.AudioInputLevelManager as any)
+
+export const AudioInputLevel = {
+  /**
+   * Set the input you want to listen to audio levels for
+   * Pass undefined to reset to system default routing.
+   *
+   * @platform Android
+   */
+  setPreferredAudioInputDevice: (uid: string | null) => {
+    AudioInputLevelManager.setPreferredAudioInputDevice(uid)
+  },
+  /**
+   * Listen to audio level changes.
+   */
+  addAudioLevelChangedListener: (callback: (level: number) => void) => {
+    return eventEmitter.addListener(AUDIO_LEVEL_CHANGED_NAME, callback)
+  },
+}
diff --git a/package/src/types/AudioInputDevice.ts b/package/src/types/AudioInputDevice.ts
new file mode 100644
index 0000000000..45ec912729
--- /dev/null
+++ b/package/src/types/AudioInputDevice.ts
@@ -0,0 +1,5 @@
+export interface AudioInputDevice {
+  portName: string
+  portType: string
+  uid: string
+}
diff --git a/package/src/types/CameraProps.ts b/package/src/types/CameraProps.ts
index 18bfc9b618..9576728406 100644
--- a/package/src/types/CameraProps.ts
+++ b/package/src/types/CameraProps.ts
@@ -7,6 +7,7 @@ import type { ISharedValue } from 'react-native-worklets-core'
 import type { SkImage } from '@shopify/react-native-skia'
 import type { OutputOrientation } from './OutputOrientation'
 import type { Orientation } from './Orientation'
+import type { AudioInputDevice } from './AudioInputDevice'
 
 export interface ReadonlyFrameProcessor {
   frameProcessor: (frame: Frame) => void
@@ -51,6 +52,12 @@ export interface CameraProps extends ViewProps {
    * ```
    */
   device: CameraDevice
+
+  /**
+   * Audio Input device to be used as the microphone.
+   */
+  audioInputDevice?: AudioInputDevice
+
   /**
    * Whether the Camera should actively stream video frames, or not. See the [documentation about the `isActive` prop](https://react-native-vision-camera.com/docs/guides/lifecycle#the-isactive-prop) for more information.
    *