diff --git a/WooCommerce-Wear/src/main/java/com/woocommerce/android/wear/di/ApplicationPasswordsModule.kt b/WooCommerce-Wear/src/main/java/com/woocommerce/android/wear/di/ApplicationPasswordsModule.kt
new file mode 100644
index 000000000000..b8b819064155
--- /dev/null
+++ b/WooCommerce-Wear/src/main/java/com/woocommerce/android/wear/di/ApplicationPasswordsModule.kt
@@ -0,0 +1,24 @@
+package com.woocommerce.android.wear.di
+
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import org.wordpress.android.fluxc.network.rest.wpapi.applicationpasswords.ApplicationPasswordsConfiguration
+import javax.inject.Inject
+
+@Module
+@InstallIn(SingletonComponent::class)
+interface ApplicationPasswordsModule {
+    @Binds
+    fun bindApplicationPasswordsConfiguration(
+        configuration: WooWearApplicationPasswordsConfiguration
+    ): ApplicationPasswordsConfiguration
+}
+
+class WooWearApplicationPasswordsConfiguration @Inject constructor() : ApplicationPasswordsConfiguration {
+    override val applicationName: String = ""
+
+    override fun isEnabledForDirectAccess(): Boolean = false
+    override suspend fun isEnabledForJetpackAccess(): Boolean = false
+}
diff --git a/WooCommerce/src/main/kotlin/com/woocommerce/android/AppPrefs.kt b/WooCommerce/src/main/kotlin/com/woocommerce/android/AppPrefs.kt
index 9f2974d0dcc2..ec1271d6e5a3 100644
--- a/WooCommerce/src/main/kotlin/com/woocommerce/android/AppPrefs.kt
+++ b/WooCommerce/src/main/kotlin/com/woocommerce/android/AppPrefs.kt
@@ -134,7 +134,8 @@ object AppPrefs {
         CUSTOM_FIELDS_TOP_BANNER_DISMISSED,
         BLAZE_CAMPAIGN_SELECTED_OBJECTIVE,
         BLAZE_CAMPAIGN_OBJECTIVE_SWITCH_CHECKED,
-        IS_SITE_WPCOM_SUSPENDED
+        IS_SITE_WPCOM_SUSPENDED,
+        JETPACK_APP_PASSWORDS_ENABLED
     }
 
     /**
@@ -301,6 +302,10 @@ object AppPrefs {
         get() = getBoolean(DeletablePrefKey.GATEWAY_MIGRATED, false)
         set(value) = setBoolean(DeletablePrefKey.GATEWAY_MIGRATED, value)
 
+    var jetpackAppPasswordsEnabled: Boolean
+        get() = getBoolean(DeletablePrefKey.JETPACK_APP_PASSWORDS_ENABLED, true)
+        set(value) = setBoolean(DeletablePrefKey.JETPACK_APP_PASSWORDS_ENABLED, value)
+
     fun getProductSortingChoice(currentSiteId: Int) = getString(getProductSortingKey(currentSiteId)).orNullIfEmpty()
 
     fun setProductSortingChoice(currentSiteId: Int, value: String) {
diff --git a/WooCommerce/src/main/kotlin/com/woocommerce/android/AppPrefsWrapper.kt b/WooCommerce/src/main/kotlin/com/woocommerce/android/AppPrefsWrapper.kt
index 3f7cdfea83ed..ea1a6ad058d0 100644
--- a/WooCommerce/src/main/kotlin/com/woocommerce/android/AppPrefsWrapper.kt
+++ b/WooCommerce/src/main/kotlin/com/woocommerce/android/AppPrefsWrapper.kt
@@ -42,6 +42,8 @@ open class AppPrefsWrapper @Inject constructor() {
     open var orderSummaryMigrated by AppPrefs::orderSummaryMigrated
     open var gatewayMigrated by AppPrefs::gatewayMigrated
 
+    var jetpackAppPasswordsEnabled by AppPrefs::jetpackAppPasswordsEnabled
+
     fun getAppInstallationDate() = AppPrefs.installationDate
 
     fun getReceiptUrl(localSiteId: Int, remoteSiteId: Long, selfHostedSiteId: Long, orderId: Long) =
diff --git a/WooCommerce/src/main/kotlin/com/woocommerce/android/applicationpasswords/WooApplicationPasswordsConfiguration.kt b/WooCommerce/src/main/kotlin/com/woocommerce/android/applicationpasswords/WooApplicationPasswordsConfiguration.kt
new file mode 100644
index 000000000000..8de9a63f32b3
--- /dev/null
+++ b/WooCommerce/src/main/kotlin/com/woocommerce/android/applicationpasswords/WooApplicationPasswordsConfiguration.kt
@@ -0,0 +1,18 @@
+package com.woocommerce.android.applicationpasswords
+
+import com.woocommerce.android.AppPrefsWrapper
+import com.woocommerce.android.BuildConfig
+import com.woocommerce.android.util.DeviceInfo
+import com.woocommerce.android.util.FeatureFlag.APP_PASSWORDS_FOR_JETPACK_SITES
+import jakarta.inject.Inject
+import org.wordpress.android.fluxc.network.rest.wpapi.applicationpasswords.ApplicationPasswordsConfiguration
+
+class WooApplicationPasswordsConfiguration @Inject constructor(
+    private val appPrefs: AppPrefsWrapper
+) : ApplicationPasswordsConfiguration {
+    override val applicationName: String =
+        "${BuildConfig.APPLICATION_ID}.app-client.${DeviceInfo.name.replace(' ', '-')}"
+
+    override suspend fun isEnabledForJetpackAccess(): Boolean =
+        APP_PASSWORDS_FOR_JETPACK_SITES.isEnabled() && appPrefs.jetpackAppPasswordsEnabled
+}
diff --git a/WooCommerce/src/main/kotlin/com/woocommerce/android/config/FirebaseRemoteConfigRepository.kt b/WooCommerce/src/main/kotlin/com/woocommerce/android/config/FirebaseRemoteConfigRepository.kt
index 7b5b9d20f420..dc843451b652 100644
--- a/WooCommerce/src/main/kotlin/com/woocommerce/android/config/FirebaseRemoteConfigRepository.kt
+++ b/WooCommerce/src/main/kotlin/com/woocommerce/android/config/FirebaseRemoteConfigRepository.kt
@@ -21,8 +21,6 @@ class FirebaseRemoteConfigRepository @Inject constructor(
     companion object {
         private const val DEBUG_INTERVAL = 10L
         private const val RELEASE_INTERVAL = 31200L
-
-        const val KEY_ENABLE_JETPACK_APP_PASSWORDS_EXPERIMENT = "wcandroid_enable_jetpack_app_passwords_experiment_2"
     }
 
     private val minimumFetchIntervalInSeconds =
@@ -37,11 +35,7 @@ class FirebaseRemoteConfigRepository @Inject constructor(
     private val _fetchStatus = MutableStateFlow(RemoteConfigFetchStatus.Pending)
     override val fetchStatus: Flow<RemoteConfigFetchStatus> = _fetchStatus.asStateFlow()
 
-    private val defaultValues by lazy {
-        mapOf(
-            KEY_ENABLE_JETPACK_APP_PASSWORDS_EXPERIMENT to false.toString()
-        )
-    }
+    private val defaultValues = emptyMap<String, String>()
 
     init {
         remoteConfig.apply {
@@ -73,8 +67,4 @@ class FirebaseRemoteConfigRepository @Inject constructor(
     @VisibleForTesting
     fun observeStringRemoteValue(key: String) = changesTrigger
         .map { remoteConfig.getString(key) }
-
-    override fun isJetpackAppPasswordsExperimentEnabled(): Boolean {
-        return remoteConfig.getBoolean(KEY_ENABLE_JETPACK_APP_PASSWORDS_EXPERIMENT)
-    }
 }
diff --git a/WooCommerce/src/main/kotlin/com/woocommerce/android/config/RemoteConfigRepository.kt b/WooCommerce/src/main/kotlin/com/woocommerce/android/config/RemoteConfigRepository.kt
index d77bf3b3be66..38c2656d0d62 100644
--- a/WooCommerce/src/main/kotlin/com/woocommerce/android/config/RemoteConfigRepository.kt
+++ b/WooCommerce/src/main/kotlin/com/woocommerce/android/config/RemoteConfigRepository.kt
@@ -5,8 +5,6 @@ import kotlinx.coroutines.flow.Flow
 interface RemoteConfigRepository {
     val fetchStatus: Flow<RemoteConfigFetchStatus>
     fun fetchRemoteConfig()
-
-    fun isJetpackAppPasswordsExperimentEnabled(): Boolean
 }
 
 enum class RemoteConfigFetchStatus {
diff --git a/WooCommerce/src/main/kotlin/com/woocommerce/android/di/ApplicationPasswordsModule.kt b/WooCommerce/src/main/kotlin/com/woocommerce/android/di/ApplicationPasswordsModule.kt
index 55ec5a7e5a88..edff7e3ca044 100644
--- a/WooCommerce/src/main/kotlin/com/woocommerce/android/di/ApplicationPasswordsModule.kt
+++ b/WooCommerce/src/main/kotlin/com/woocommerce/android/di/ApplicationPasswordsModule.kt
@@ -1,14 +1,12 @@
 package com.woocommerce.android.di
 
-import com.woocommerce.android.BuildConfig
 import com.woocommerce.android.applicationpasswords.ApplicationPasswordsNotifier
-import com.woocommerce.android.util.DeviceInfo
+import com.woocommerce.android.applicationpasswords.WooApplicationPasswordsConfiguration
 import dagger.Binds
 import dagger.Module
-import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.components.SingletonComponent
-import org.wordpress.android.fluxc.module.ApplicationPasswordsClientId
+import org.wordpress.android.fluxc.network.rest.wpapi.applicationpasswords.ApplicationPasswordsConfiguration
 import org.wordpress.android.fluxc.network.rest.wpapi.applicationpasswords.ApplicationPasswordsListener
 
 @Module
@@ -19,10 +17,8 @@ interface ApplicationPasswordsModule {
         notifier: ApplicationPasswordsNotifier
     ): ApplicationPasswordsListener
 
-    companion object {
-        @Provides
-        @ApplicationPasswordsClientId
-        fun providesApplicationPasswordClientId() =
-            "${BuildConfig.APPLICATION_ID}.app-client.${DeviceInfo.name.replace(' ', '-')}"
-    }
+    @Binds
+    fun bindApplicationPasswordsConfiguration(
+        configuration: WooApplicationPasswordsConfiguration
+    ): ApplicationPasswordsConfiguration
 }
diff --git a/WooCommerce/src/main/kotlin/com/woocommerce/android/ui/login/sitecredentials/LoginSiteCredentialsViewModel.kt b/WooCommerce/src/main/kotlin/com/woocommerce/android/ui/login/sitecredentials/LoginSiteCredentialsViewModel.kt
index 121c57ba5399..f91a0332d050 100644
--- a/WooCommerce/src/main/kotlin/com/woocommerce/android/ui/login/sitecredentials/LoginSiteCredentialsViewModel.kt
+++ b/WooCommerce/src/main/kotlin/com/woocommerce/android/ui/login/sitecredentials/LoginSiteCredentialsViewModel.kt
@@ -37,8 +37,8 @@ import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
 import org.wordpress.android.fluxc.model.SiteModel
-import org.wordpress.android.fluxc.module.ApplicationPasswordsClientId
 import org.wordpress.android.fluxc.network.rest.wpapi.Nonce.CookieNonceErrorType.INVALID_CREDENTIALS
+import org.wordpress.android.fluxc.network.rest.wpapi.applicationpasswords.ApplicationPasswordsConfiguration
 import org.wordpress.android.fluxc.store.SiteStore.SiteError
 import org.wordpress.android.login.LoginAnalyticsListener
 import org.wordpress.android.util.UrlUtils
@@ -55,7 +55,7 @@ class LoginSiteCredentialsViewModel @Inject constructor(
     private val analyticsTracker: AnalyticsTrackerWrapper,
     private val appPrefs: AppPrefsWrapper,
     private val resourceProvider: ResourceProvider,
-    @ApplicationPasswordsClientId private val applicationPasswordsClientId: String
+    private val applicationPasswordsConfiguration: ApplicationPasswordsConfiguration
 ) : ScopedViewModel(savedStateHandle) {
     companion object {
         const val SITE_ADDRESS_KEY = "site-address"
@@ -82,7 +82,9 @@ class LoginSiteCredentialsViewModel @Inject constructor(
 
     private val SiteModel?.fullAuthorizationUrl: String?
         get() = this?.applicationPasswordsAuthorizeUrl
-            ?.let { url -> "$url?app_name=$applicationPasswordsClientId&success_url=$REDIRECTION_URL" }
+            ?.let { url ->
+                "$url?app_name=${applicationPasswordsConfiguration.applicationName}&success_url=$REDIRECTION_URL"
+            }
 
     val viewState = combine(
         flowOf(siteAddress.removeSchemeAndSuffix()),
diff --git a/WooCommerce/src/main/kotlin/com/woocommerce/android/ui/orders/list/OrderListItemDataSource.kt b/WooCommerce/src/main/kotlin/com/woocommerce/android/ui/orders/list/OrderListItemDataSource.kt
index 8d0d7e9c93db..e147e19c019d 100644
--- a/WooCommerce/src/main/kotlin/com/woocommerce/android/ui/orders/list/OrderListItemDataSource.kt
+++ b/WooCommerce/src/main/kotlin/com/woocommerce/android/ui/orders/list/OrderListItemDataSource.kt
@@ -1,7 +1,6 @@
 package com.woocommerce.android.ui.orders.list
 
 import com.woocommerce.android.R
-import com.woocommerce.android.config.RemoteConfigRepository
 import com.woocommerce.android.extensions.getBillingName
 import com.woocommerce.android.model.TimeGroup
 import com.woocommerce.android.model.TimeGroup.GROUP_FUTURE
@@ -45,8 +44,7 @@ class OrderListItemDataSource @Inject constructor(
     private val networkStatus: NetworkStatus,
     private val fetcher: FetchOrdersRepository,
     private val resourceProvider: ResourceProvider,
-    private val dateUtils: DateUtils,
-    private val remoteConfigRepository: RemoteConfigRepository
+    private val dateUtils: DateUtils
 ) : ListItemDataSourceInterface<WCOrderListDescriptor, OrderListItemIdentifier, OrderListItemUIType> {
     override fun getItemsAndFetchIfNecessary(
         listDescriptor: WCOrderListDescriptor,
@@ -195,8 +193,7 @@ class OrderListItemDataSource @Inject constructor(
     override fun fetchList(listDescriptor: WCOrderListDescriptor, offset: Long) {
         val fetchOrderListPayload = FetchOrderListPayload(
             listDescriptor = listDescriptor,
-            offset = offset,
-            useAppPasswordsForJetpackSites = remoteConfigRepository.isJetpackAppPasswordsExperimentEnabled()
+            offset = offset
         )
         dispatcher.dispatch(WCOrderActionBuilder.newFetchOrderListAction(fetchOrderListPayload))
     }
diff --git a/WooCommerce/src/main/kotlin/com/woocommerce/android/ui/prefs/BetaFeaturesFragment.kt b/WooCommerce/src/main/kotlin/com/woocommerce/android/ui/prefs/BetaFeaturesFragment.kt
index 1f492a5d1c89..dff605f7d515 100644
--- a/WooCommerce/src/main/kotlin/com/woocommerce/android/ui/prefs/BetaFeaturesFragment.kt
+++ b/WooCommerce/src/main/kotlin/com/woocommerce/android/ui/prefs/BetaFeaturesFragment.kt
@@ -3,6 +3,7 @@ package com.woocommerce.android.ui.prefs
 import android.os.Bundle
 import android.view.View
 import android.widget.CompoundButton
+import androidx.core.view.isVisible
 import androidx.fragment.app.Fragment
 import com.google.android.material.snackbar.BaseTransientBottomBar
 import com.google.android.material.snackbar.Snackbar
@@ -11,9 +12,13 @@ import com.woocommerce.android.R
 import com.woocommerce.android.analytics.AnalyticsEvent.PRODUCT_ADDONS_BETA_FEATURES_SWITCH_TOGGLED
 import com.woocommerce.android.analytics.AnalyticsTracker
 import com.woocommerce.android.databinding.FragmentSettingsBetaBinding
+import com.woocommerce.android.tools.SelectedSite
+import com.woocommerce.android.tools.SiteConnectionType
 import com.woocommerce.android.ui.prefs.MainSettingsFragment.AppSettingsListener
 import com.woocommerce.android.util.AnalyticsUtils
+import com.woocommerce.android.util.FeatureFlag
 import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class BetaFeaturesFragment : Fragment(R.layout.fragment_settings_beta) {
@@ -21,6 +26,9 @@ class BetaFeaturesFragment : Fragment(R.layout.fragment_settings_beta) {
         const val TAG = "beta-features"
     }
 
+    @Inject
+    lateinit var selectedSite: SelectedSite
+
     private val settingsListener by lazy {
         activity as? AppSettingsListener
     }
@@ -30,6 +38,7 @@ class BetaFeaturesFragment : Fragment(R.layout.fragment_settings_beta) {
 
         with(FragmentSettingsBetaBinding.bind(view)) {
             bindProductAddonsToggle()
+            bindJetpackAppPasswordsToggle()
         }
     }
 
@@ -49,11 +58,22 @@ class BetaFeaturesFragment : Fragment(R.layout.fragment_settings_beta) {
         }
     }
 
+    private fun FragmentSettingsBetaBinding.bindJetpackAppPasswordsToggle() {
+        // TODO check the remote feature flag state once available
+        val isJetpackSite = selectedSite.connectionType != SiteConnectionType.ApplicationPasswords
+        jetpackAppPasswordsToggle.isVisible = FeatureFlag.APP_PASSWORDS_FOR_JETPACK_SITES.isEnabled() && isJetpackSite
+
+        jetpackAppPasswordsToggle.isChecked = AppPrefs.jetpackAppPasswordsEnabled
+        jetpackAppPasswordsToggle.setOnCheckedChangeListener { _, isChecked ->
+            AppPrefs.jetpackAppPasswordsEnabled = isChecked
+        }
+    }
+
     override fun onResume() {
         super.onResume()
         AnalyticsTracker.trackViewShown(this)
 
-        activity?.setTitle(R.string.beta_features)
+        activity?.setTitle(R.string.experimental_features)
     }
 
     private fun FragmentSettingsBetaBinding.handleToggleChangeFailure(switch: CompoundButton, isChecked: Boolean) {
diff --git a/WooCommerce/src/main/kotlin/com/woocommerce/android/ui/prefs/MainSettingsFragment.kt b/WooCommerce/src/main/kotlin/com/woocommerce/android/ui/prefs/MainSettingsFragment.kt
index 05e08fd4a14d..4acf4f815c70 100644
--- a/WooCommerce/src/main/kotlin/com/woocommerce/android/ui/prefs/MainSettingsFragment.kt
+++ b/WooCommerce/src/main/kotlin/com/woocommerce/android/ui/prefs/MainSettingsFragment.kt
@@ -121,8 +121,6 @@ class MainSettingsFragment : Fragment(R.layout.fragment_settings_main), MainSett
             AppPrefs.setImageOptimizationEnabled(isChecked)
         }
 
-        updateStoreSettings()
-
         binding.optionHelpAndSupport.setOnClickListener {
             AnalyticsTracker.track(AnalyticsEvent.MAIN_MENU_CONTACT_SUPPORT_TAPPED)
             startActivity(HelpActivity.createIntent(requireActivity(), HelpOrigin.SETTINGS, null))
@@ -304,18 +302,6 @@ class MainSettingsFragment : Fragment(R.layout.fragment_settings_main), MainSett
         binding.optionNotifications.hide()
     }
 
-    private fun updateStoreSettings() {
-        generateBetaFeaturesTitleList()
-            .joinToString(", ")
-            .takeIf { it.isNotEmpty() }
-            ?.let { binding.optionBetaFeatures.optionValue = it }
-    }
-
-    private fun generateBetaFeaturesTitleList() =
-        mutableListOf<String>().apply {
-            add(getString(R.string.beta_features_add_ons))
-        }
-
     private fun showThemeChooser() {
         val currentTheme = AppPrefs.getAppTheme()
         val valuesArray = ThemeOption.values().map { getString(it.label) }.toTypedArray()
diff --git a/WooCommerce/src/main/kotlin/com/woocommerce/android/util/FeatureFlag.kt b/WooCommerce/src/main/kotlin/com/woocommerce/android/util/FeatureFlag.kt
index a59b54b144c3..ef6a016fbe76 100644
--- a/WooCommerce/src/main/kotlin/com/woocommerce/android/util/FeatureFlag.kt
+++ b/WooCommerce/src/main/kotlin/com/woocommerce/android/util/FeatureFlag.kt
@@ -16,7 +16,8 @@ enum class FeatureFlag {
     WOO_POS_HISTORICAL_ORDERS_M1,
     WOO_POS_LOCAL_CATALOG_M1,
     HIDE_SITES_FROM_SITE_PICKER,
-    AI_PRODUCT_IMAGE_BACKGROUND_REMOVAL;
+    AI_PRODUCT_IMAGE_BACKGROUND_REMOVAL,
+    APP_PASSWORDS_FOR_JETPACK_SITES;
 
     fun isEnabled(context: Context? = null): Boolean {
         return when (this) {
@@ -29,7 +30,8 @@ enum class FeatureFlag {
             BETTER_CUSTOMER_SEARCH_M2,
             ORDER_CREATION_AUTO_TAX_RATE,
             AI_PRODUCT_IMAGE_BACKGROUND_REMOVAL,
-            WOO_POS_LOCAL_CATALOG_M1 -> PackageUtils.isDebugBuild()
+            WOO_POS_LOCAL_CATALOG_M1,
+            APP_PASSWORDS_FOR_JETPACK_SITES -> PackageUtils.isDebugBuild()
 
             NEW_SHIPPING_SUPPORT,
             BULK_UPDATE_ORDERS_STATUS,
diff --git a/WooCommerce/src/main/res/layout/fragment_settings_beta.xml b/WooCommerce/src/main/res/layout/fragment_settings_beta.xml
index 02d1a53b01f4..fddd26ee91d0 100644
--- a/WooCommerce/src/main/res/layout/fragment_settings_beta.xml
+++ b/WooCommerce/src/main/res/layout/fragment_settings_beta.xml
@@ -14,6 +14,13 @@
         app:toggleOptionDesc="@string/settings_enable_product_addons_teaser_message"
         app:toggleOptionTitle="@string/settings_enable_product_addons_teaser_title" />
 
+    <com.woocommerce.android.ui.prefs.WCSettingsToggleOptionView
+        android:id="@+id/jetpackAppPasswordsToggle"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        app:toggleOptionDesc="@string/settings_enable_jetpack_app_passwords_message"
+        app:toggleOptionTitle="@string/settings_enable_jetpack_app_passwords_title" />
+
     <View style="@style/Woo.Divider" />
 
 </LinearLayout>
diff --git a/WooCommerce/src/main/res/layout/fragment_settings_main.xml b/WooCommerce/src/main/res/layout/fragment_settings_main.xml
index de2bc954b234..0c341c4dd1d4 100644
--- a/WooCommerce/src/main/res/layout/fragment_settings_main.xml
+++ b/WooCommerce/src/main/res/layout/fragment_settings_main.xml
@@ -203,8 +203,7 @@
             android:id="@+id/option_beta_features"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
-            app:optionTitle="@string/beta_features"
-            app:optionValue="@string/beta_features_add_ons" />
+            app:optionTitle="@string/experimental_features" />
 
         <!--
             Send Feedback
diff --git a/WooCommerce/src/main/res/values/strings.xml b/WooCommerce/src/main/res/values/strings.xml
index bacef6ffdff2..e11fbd913f37 100644
--- a/WooCommerce/src/main/res/values/strings.xml
+++ b/WooCommerce/src/main/res/values/strings.xml
@@ -2505,9 +2505,7 @@
     <string name="settings">Settings</string>
     <string name="privacy_settings">Privacy settings</string>
     <string name="send_feedback">Send feedback</string>
-    <string name="beta_features">Beta features</string>
-    <string name="beta_features_add_ons">View Add-ons</string>
-    <string name="beta_features_simple_payments">Simple payments</string>
+    <string name="experimental_features">Experimental features</string>
     <string name="settings_signout">Log out</string>
     <string name="settings_close_account">Close Account</string>
     <string name="settings_close_account_dialog_title">Confirm Close Account</string>
@@ -2612,6 +2610,8 @@
     <string name="plugin_state_inactive">Inactive</string>
     <string name="plugin_state_auto_managed">Auto-managed</string>
     <string name="plugins_error_message">An error occurred while loading installed plugins</string>
+    <string name="settings_enable_jetpack_app_passwords_title">Application Passwords</string>
+    <string name="settings_enable_jetpack_app_passwords_message">Enable application passwords to let the app directly fetch data from your WooCommerce site instead of doing so through Jetpack connection.</string>
 
     <!--
         Developer Options Screen
diff --git a/WooCommerce/src/test/kotlin/com/woocommerce/android/ui/login/sitecredentials/LoginSiteCredentialsViewModelTest.kt b/WooCommerce/src/test/kotlin/com/woocommerce/android/ui/login/sitecredentials/LoginSiteCredentialsViewModelTest.kt
index e310699ca7d0..17f55c1e206f 100644
--- a/WooCommerce/src/test/kotlin/com/woocommerce/android/ui/login/sitecredentials/LoginSiteCredentialsViewModelTest.kt
+++ b/WooCommerce/src/test/kotlin/com/woocommerce/android/ui/login/sitecredentials/LoginSiteCredentialsViewModelTest.kt
@@ -39,6 +39,7 @@ import org.wordpress.android.fluxc.network.BaseRequest.BaseNetworkError
 import org.wordpress.android.fluxc.network.BaseRequest.GenericErrorType
 import org.wordpress.android.fluxc.network.rest.wpapi.Nonce
 import org.wordpress.android.fluxc.network.rest.wpapi.WPAPINetworkError
+import org.wordpress.android.fluxc.network.rest.wpapi.applicationpasswords.ApplicationPasswordsConfiguration
 import org.wordpress.android.login.LoginAnalyticsListener
 
 @ExperimentalCoroutinesApi
@@ -95,7 +96,10 @@ class LoginSiteCredentialsViewModelTest : BaseUnitTest() {
             applicationPasswordsNotifier = applicationPasswordsNotifier,
             analyticsTracker = analyticsTracker,
             appPrefs = appPrefs,
-            applicationPasswordsClientId = clientId,
+            applicationPasswordsConfiguration = object : ApplicationPasswordsConfiguration {
+                override val applicationName: String = clientId
+                override suspend fun isEnabledForJetpackAccess(): Boolean = true
+            },
             resourceProvider = resourceProvider
         )
     }
@@ -292,22 +296,23 @@ class LoginSiteCredentialsViewModelTest : BaseUnitTest() {
     }
 
     @Test
-    fun `given application pwd disabled and wp-login-php accessible, when submitting login, then show error screen`() = testBlocking {
-        setup {
-            whenever(wpApiSiteRepository.checkIfUserIsEligible(testSite)).thenReturn(Result.failure(Exception()))
-        }
-
-        viewModel.viewState.observeForTesting {
-            viewModel.onUsernameChanged(testUsername)
-            viewModel.onPasswordChanged(testPassword)
-            viewModel.onContinueClick()
-            applicationPasswordsUnavailableEvents.tryEmit(mock())
+    fun `given application pwd disabled and wp-login-php accessible, when submitting login, then show error screen`() =
+        testBlocking {
+            setup {
+                whenever(wpApiSiteRepository.checkIfUserIsEligible(testSite)).thenReturn(Result.failure(Exception()))
+            }
+
+            viewModel.viewState.observeForTesting {
+                viewModel.onUsernameChanged(testUsername)
+                viewModel.onPasswordChanged(testPassword)
+                viewModel.onContinueClick()
+                applicationPasswordsUnavailableEvents.tryEmit(mock())
+            }
+
+            assertThat(viewModel.event.value)
+                .isEqualTo(ShowApplicationPasswordsUnavailableScreen(siteAddress, isJetpackConnected))
         }
 
-        assertThat(viewModel.event.value)
-            .isEqualTo(ShowApplicationPasswordsUnavailableScreen(siteAddress, isJetpackConnected))
-    }
-
     @Test
     fun `give user role fetch fails, when submitting login, then show a snackbar`() = testBlocking {
         setup {
@@ -353,23 +358,24 @@ class LoginSiteCredentialsViewModelTest : BaseUnitTest() {
     }
 
     @Test
-    fun `given application passwords enabled and login fails for an unknown reason, when user attempts to sign-in, then show WebView login flow`() = testBlocking {
-        setup {
-            whenever(wpApiSiteRepository.login(siteAddress, testUsername, testPassword))
-                .thenReturn(Result.failure(Exception()))
-            whenever(wpApiSiteRepository.fetchSite(siteAddress))
-                .thenReturn(Result.success(testSite.apply { applicationPasswordsAuthorizeUrl = urlAuthBase }))
+    fun `given application passwords enabled and login fails for an unknown reason, when user attempts to sign-in, then show WebView login flow`() =
+        testBlocking {
+            setup {
+                whenever(wpApiSiteRepository.login(siteAddress, testUsername, testPassword))
+                    .thenReturn(Result.failure(Exception()))
+                whenever(wpApiSiteRepository.fetchSite(siteAddress))
+                    .thenReturn(Result.success(testSite.apply { applicationPasswordsAuthorizeUrl = urlAuthBase }))
+            }
+
+            val event = viewModel.event.runAndCaptureValues {
+                viewModel.onUsernameChanged(testUsername)
+                viewModel.onPasswordChanged(testPassword)
+                viewModel.viewState.getOrAwaitValue()
+                viewModel.onContinueClick()
+            }.last()
+
+            assertThat(event).isInstanceOf(LoginSiteCredentialsViewModel.ShowApplicationPasswordTutorialScreen::class.java)
+            assertThat((event as LoginSiteCredentialsViewModel.ShowApplicationPasswordTutorialScreen).url)
+                .isEqualTo(urlAuthFull)
         }
-
-        val event = viewModel.event.runAndCaptureValues {
-            viewModel.onUsernameChanged(testUsername)
-            viewModel.onPasswordChanged(testPassword)
-            viewModel.viewState.getOrAwaitValue()
-            viewModel.onContinueClick()
-        }.last()
-
-        assertThat(event).isInstanceOf(LoginSiteCredentialsViewModel.ShowApplicationPasswordTutorialScreen::class.java)
-        assertThat((event as LoginSiteCredentialsViewModel.ShowApplicationPasswordTutorialScreen).url)
-            .isEqualTo(urlAuthFull)
-    }
 }
diff --git a/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/network/rest/wpcom/wc/WooExperimentalNetwork.kt b/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/network/rest/wpcom/wc/WooExperimentalNetwork.kt
deleted file mode 100644
index 2e4d2e955f6e..000000000000
--- a/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/network/rest/wpcom/wc/WooExperimentalNetwork.kt
+++ /dev/null
@@ -1,181 +0,0 @@
-package org.wordpress.android.fluxc.network.rest.wpcom.wc
-
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-import org.wordpress.android.fluxc.model.SiteModel
-import org.wordpress.android.fluxc.network.rest.wpapi.WPAPINetwork
-import org.wordpress.android.fluxc.network.rest.wpapi.WPAPINetworkingMode
-import org.wordpress.android.fluxc.network.rest.wpapi.WPAPIResponse
-import org.wordpress.android.fluxc.network.rest.wpapi.applicationpasswords.ApplicationPasswordsNetwork
-import org.wordpress.android.fluxc.network.rest.wpapi.applicationpasswords.ApplicationPasswordsStore
-import org.wordpress.android.fluxc.network.rest.wpcom.JetpackTunnelWPAPINetwork
-import org.wordpress.android.fluxc.persistence.SiteSqlUtils
-import org.wordpress.android.util.AppLog
-import javax.inject.Inject
-import javax.inject.Singleton
-
-/**
- * An experimental network class for WooCommerce that allows using Application Passwords for Jetpack sites too,
- * it will allow us to confirm if the Jetpack Tunnel is causing performance issues.
- *
- * Depending on the results of this experiment, we will either move the logic to the existing WooNetwork class or
- * drop the experiment.
- */
-@Singleton
-class WooExperimentalNetwork @Inject constructor(
-    private val applicationPasswordsNetwork: ApplicationPasswordsNetwork,
-    private val jetpackTunnelWPAPINetwork: JetpackTunnelWPAPINetwork,
-    private val applicationPasswordsStore: ApplicationPasswordsStore,
-    private val siteSqlUtils: SiteSqlUtils
-) : WPAPINetwork {
-    override suspend fun <T : Any> executeGetGsonRequest(
-        site: SiteModel,
-        path: String,
-        clazz: Class<T>,
-        params: Map<String, String>,
-        enableCaching: Boolean,
-        cacheTimeToLive: Int,
-        forced: Boolean,
-        requestTimeout: Int,
-        retries: Int
-    ): WPAPIResponse<T> = handleRequest(site) {
-        executeGetGsonRequest(
-            site = site,
-            path = path,
-            clazz = clazz,
-            params = params,
-            enableCaching = enableCaching,
-            cacheTimeToLive = cacheTimeToLive,
-            forced = forced,
-            requestTimeout = requestTimeout,
-            retries = retries
-        )
-    }
-
-    override suspend fun <T : Any> executePostGsonRequest(
-        site: SiteModel,
-        path: String,
-        clazz: Class<T>,
-        body: Map<String, Any>
-    ): WPAPIResponse<T> = handleRequest(site) {
-        executePostGsonRequest(
-            site = site,
-            path = path,
-            clazz = clazz,
-            body = body
-        )
-    }
-
-    override suspend fun <T : Any> executePutGsonRequest(
-        site: SiteModel,
-        path: String,
-        clazz: Class<T>,
-        body: Map<String, Any>
-    ): WPAPIResponse<T> = handleRequest(site) {
-        executePutGsonRequest(
-            site = site,
-            path = path,
-            clazz = clazz,
-            body = body
-        )
-    }
-
-    override suspend fun <T : Any> executeDeleteGsonRequest(
-        site: SiteModel,
-        path: String,
-        clazz: Class<T>,
-        params: Map<String, String>
-    ): WPAPIResponse<T> = handleRequest(site) {
-        executeDeleteGsonRequest(
-            site = site,
-            path = path,
-            clazz = clazz,
-            params = params
-        )
-    }
-
-    private suspend fun <T : Any> handleRequest(
-        site: SiteModel,
-        request: suspend WPAPINetwork.() -> WPAPIResponse<T>
-    ): WPAPIResponse<T> {
-        return when (site.origin) {
-            SiteModel.ORIGIN_WPAPI, SiteModel.ORIGIN_XMLRPC -> {
-                applicationPasswordsNetwork.request().copyWith(
-                    networkingMode = WPAPINetworkingMode.ApplicationPasswords
-                )
-            }
-
-            SiteModel.ORIGIN_WPCOM_REST -> {
-                handleRequestForJetpackSites(site) {
-                    request()
-                }
-            }
-
-            else -> {
-                throw IllegalArgumentException("Unsupported site origin: ${site.origin}")
-            }
-        }
-    }
-
-    private suspend fun <T : Any> handleRequestForJetpackSites(
-        site: SiteModel,
-        request: suspend WPAPINetwork.() -> WPAPIResponse<T>
-    ): WPAPIResponse<T> {
-        if (!site.isApplicationPasswordsSupported) {
-            AppLog.v(
-                AppLog.T.API,
-                "Application Passwords not supported for site: ${site.url}, use Jetpack Tunnel"
-            )
-            return jetpackTunnelWPAPINetwork.request().copyWith(
-                networkingMode = WPAPINetworkingMode.JetpackTunnel()
-            )
-        }
-
-        val hasAppPassword = applicationPasswordsStore.hasCredentials(site)
-
-        return when (val appPasswordsResponse = applicationPasswordsNetwork.request()) {
-            is WPAPIResponse.Success<*> -> {
-                AppLog.v(
-                    AppLog.T.API,
-                    "Request successful for site: ${site.url}, using Application Passwords"
-                )
-                (appPasswordsResponse as WPAPIResponse<T>).copyWith(
-                    // When creating a new Application Password, we don't want to track this request, as its duration
-                    // is not relevant to our experiment.
-                    // So we track only requests where we already have a password saved.
-                    networkingMode = if (hasAppPassword) WPAPINetworkingMode.ApplicationPasswordsWithJetpack else null
-                )
-            }
-
-            is WPAPIResponse.Error<*> -> {
-                AppLog.w(
-                    AppLog.T.API,
-                    "Request failed for site: ${site.url} using Application Passwords, falling back to Jetpack Tunnel"
-                )
-                if (appPasswordsResponse.error.errorCode ==
-                    ApplicationPasswordsNetwork.APPLICATION_PASSWORDS_NOT_SUPPORT_ERROR_CODE
-                ) {
-                    withContext(Dispatchers.IO) {
-                        site.applicationPasswordsAuthorizeUrl = null
-                        siteSqlUtils.insertOrUpdateSite(site)
-                    }
-                }
-                jetpackTunnelWPAPINetwork.request().copyWith(
-                    networkingMode = WPAPINetworkingMode.JetpackTunnel(
-                        isFallback = true,
-                        applicationPasswordsError = appPasswordsResponse.error
-                    )
-                )
-            }
-        }
-    }
-
-    private fun <T : Any> WPAPIResponse<T>.copyWith(
-        networkingMode: WPAPINetworkingMode?
-    ): WPAPIResponse<T> {
-        return when (this) {
-            is WPAPIResponse.Success -> this.copy(networkingMode = networkingMode)
-            is WPAPIResponse.Error -> this.copy(networkingMode = networkingMode)
-        }
-    }
-}
diff --git a/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/network/rest/wpcom/wc/WooNetwork.kt b/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/network/rest/wpcom/wc/WooNetwork.kt
index 31c943af10f9..a87077de7fa5 100644
--- a/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/network/rest/wpcom/wc/WooNetwork.kt
+++ b/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/network/rest/wpcom/wc/WooNetwork.kt
@@ -1,25 +1,36 @@
 package org.wordpress.android.fluxc.network.rest.wpcom.wc
 
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
 import org.wordpress.android.fluxc.model.SiteModel
 import org.wordpress.android.fluxc.network.rest.wpapi.WPAPINetwork
+import org.wordpress.android.fluxc.network.rest.wpapi.WPAPINetworkError
+import org.wordpress.android.fluxc.network.rest.wpapi.WPAPINetworkingMode
 import org.wordpress.android.fluxc.network.rest.wpapi.WPAPIResponse
+import org.wordpress.android.fluxc.network.rest.wpapi.applicationpasswords.ApplicationPasswordsConfiguration
 import org.wordpress.android.fluxc.network.rest.wpapi.applicationpasswords.ApplicationPasswordsNetwork
 import org.wordpress.android.fluxc.network.rest.wpcom.JetpackTunnelWPAPINetwork
+import org.wordpress.android.fluxc.persistence.SiteSqlUtils
+import org.wordpress.android.util.AppLog
 import javax.inject.Inject
 import javax.inject.Singleton
 
 /**
  * The Woo app supports connecting to sites using either Jetpack or the site credentials (technically application
  * passwords). This class allows this by supporting multiple networking implementations depending on the type of site:
- * - Jetpack Sites: the API call will use Jetpack Tunnel using [JetpackTunnelWPAPINetwork]
+ * - Jetpack Sites:
+ *     - When enabled and if the site supports it, the API call will use [ApplicationPasswordsNetwork]
+ *     - Otherwise, it will use [JetpackTunnelWPAPINetwork]
  * - Non-Jetpack Sites: the API call will use Application Passwords using [ApplicationPasswordsNetwork]
  *
  * The [SiteModel.ORIGIN_XMLRPC] support is kept for backward compatibility
  */
 @Singleton
 class WooNetwork @Inject constructor(
+    private val applicationPasswordsConfiguration: ApplicationPasswordsConfiguration,
+    private val applicationPasswordsNetwork: ApplicationPasswordsNetwork,
     private val jetpackTunnelWPAPINetwork: JetpackTunnelWPAPINetwork,
-    private val applicationPasswordsNetwork: ApplicationPasswordsNetwork
+    private val siteSqlUtils: SiteSqlUtils
 ) : WPAPINetwork {
     override suspend fun <T : Any> executeGetGsonRequest(
         site: SiteModel,
@@ -31,8 +42,8 @@ class WooNetwork @Inject constructor(
         forced: Boolean,
         requestTimeout: Int,
         retries: Int
-    ): WPAPIResponse<T> = site.getDelegate()
-        .executeGetGsonRequest(
+    ): WPAPIResponse<T> = handleRequest(site, RequestContext(path, "GET")) {
+        executeGetGsonRequest(
             site = site,
             path = path,
             clazz = clazz,
@@ -43,49 +54,143 @@ class WooNetwork @Inject constructor(
             requestTimeout = requestTimeout,
             retries = retries
         )
+    }
 
     override suspend fun <T : Any> executePostGsonRequest(
         site: SiteModel,
         path: String,
         clazz: Class<T>,
         body: Map<String, Any>
-    ): WPAPIResponse<T> = site.getDelegate()
-        .executePostGsonRequest(
+    ): WPAPIResponse<T> = handleRequest(site, RequestContext(path, "POST")) {
+        executePostGsonRequest(
             site = site,
             path = path,
             clazz = clazz,
             body = body
         )
+    }
 
     override suspend fun <T : Any> executePutGsonRequest(
         site: SiteModel,
         path: String,
         clazz: Class<T>,
         body: Map<String, Any>
-    ): WPAPIResponse<T> = site.getDelegate()
-        .executePutGsonRequest(
+    ): WPAPIResponse<T> = handleRequest(site, RequestContext(path, "PUT")) {
+        executePutGsonRequest(
             site = site,
             path = path,
             clazz = clazz,
             body = body
         )
+    }
 
     override suspend fun <T : Any> executeDeleteGsonRequest(
         site: SiteModel,
         path: String,
         clazz: Class<T>,
         params: Map<String, String>
-    ): WPAPIResponse<T> = site.getDelegate()
-        .executeDeleteGsonRequest(
+    ): WPAPIResponse<T> = handleRequest(site, RequestContext(path, "DELETE")) {
+        executeDeleteGsonRequest(
             site = site,
             path = path,
             clazz = clazz,
             params = params
         )
+    }
+
+    private suspend fun <T : Any> handleRequest(
+        site: SiteModel,
+        requestContext: RequestContext,
+        request: suspend WPAPINetwork.() -> WPAPIResponse<T>
+    ): WPAPIResponse<T> {
+        return when (site.origin) {
+            SiteModel.ORIGIN_WPAPI, SiteModel.ORIGIN_XMLRPC -> {
+                applicationPasswordsNetwork.request().copyWith(
+                    networkingMode = WPAPINetworkingMode.ApplicationPasswords
+                )
+            }
+
+            SiteModel.ORIGIN_WPCOM_REST -> {
+                handleRequestForJetpackSites(site, requestContext) {
+                    request()
+                }
+            }
 
-    private fun SiteModel.getDelegate() = when (origin) {
-        SiteModel.ORIGIN_WPCOM_REST -> jetpackTunnelWPAPINetwork
-        SiteModel.ORIGIN_XMLRPC, SiteModel.ORIGIN_WPAPI -> applicationPasswordsNetwork
-        else -> error("Site with unsupported origin")
+            else -> {
+                throw IllegalArgumentException("Unsupported site origin: ${site.origin}")
+            }
+        }
     }
+
+    private suspend fun <T : Any> handleRequestForJetpackSites(
+        site: SiteModel,
+        requestContext: RequestContext,
+        request: suspend WPAPINetwork.() -> WPAPIResponse<T>
+    ): WPAPIResponse<T> {
+        val appPasswordsEnabled = applicationPasswordsConfiguration.isEnabledForJetpackAccess()
+        if (!appPasswordsEnabled || !site.isApplicationPasswordsSupported) {
+            if (appPasswordsEnabled) {
+                AppLog.v(
+                    AppLog.T.API,
+                    "Application Passwords not supported for site: ${site.url}, use Jetpack Tunnel"
+                )
+            }
+            return jetpackTunnelWPAPINetwork.request().copyWith(
+                networkingMode = WPAPINetworkingMode.JetpackTunnel()
+            )
+        }
+
+        return when (val appPasswordsResponse = applicationPasswordsNetwork.request()) {
+            is WPAPIResponse.Success<*> -> {
+                (appPasswordsResponse as WPAPIResponse<T>).copyWith(
+                    networkingMode = WPAPINetworkingMode.ApplicationPasswordsWithJetpack
+                )
+            }
+
+            is WPAPIResponse.Error<*> -> {
+                logMessageForFailedRequest(requestContext, site.url, appPasswordsResponse.error)
+
+                if (appPasswordsResponse.error.errorCode ==
+                    ApplicationPasswordsNetwork.APPLICATION_PASSWORDS_NOT_SUPPORT_ERROR_CODE
+                ) {
+                    withContext(Dispatchers.IO) {
+                        site.applicationPasswordsAuthorizeUrl = null
+                        siteSqlUtils.insertOrUpdateSite(site)
+                    }
+                }
+                jetpackTunnelWPAPINetwork.request().copyWith(
+                    networkingMode = WPAPINetworkingMode.JetpackTunnel(
+                        isFallback = true,
+                        applicationPasswordsError = appPasswordsResponse.error
+                    )
+                )
+            }
+        }
+    }
+
+    private fun <T : Any> WPAPIResponse<T>.copyWith(
+        networkingMode: WPAPINetworkingMode?
+    ): WPAPIResponse<T> {
+        return when (this) {
+            is WPAPIResponse.Success -> this.copy(networkingMode = networkingMode)
+            is WPAPIResponse.Error -> this.copy(networkingMode = networkingMode)
+        }
+    }
+
+    private fun logMessageForFailedRequest(requestContext: RequestContext, siteUrl: String, error: WPAPINetworkError) {
+        AppLog.w(
+            AppLog.T.API,
+            "Request failed using Application Passwords for Jetpack Site,\n" +
+                "site: $siteUrl,\n" +
+                "path: ${requestContext.path},\n" +
+                "method: ${requestContext.method},\n" +
+                "error: HTTP status code ${error.volleyError?.networkResponse?.statusCode}, " +
+                "error message: ${error.errorCode?.ifEmpty { null } ?: error.message}",
+        )
+    }
+
+    private data class RequestContext(
+        val path: String,
+        val method: String
+    )
 }
diff --git a/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/network/rest/wpcom/wc/order/OrderRestClient.kt b/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/network/rest/wpcom/wc/order/OrderRestClient.kt
index 7aef5c3fb7a9..e40417e3983b 100644
--- a/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/network/rest/wpcom/wc/order/OrderRestClient.kt
+++ b/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/network/rest/wpcom/wc/order/OrderRestClient.kt
@@ -21,7 +21,6 @@ import org.wordpress.android.fluxc.model.order.UpdateOrderRequest
 import org.wordpress.android.fluxc.network.BaseRequest
 import org.wordpress.android.fluxc.network.rest.wpapi.WPAPINetworkError
 import org.wordpress.android.fluxc.network.rest.wpapi.WPAPIResponse
-import org.wordpress.android.fluxc.network.rest.wpcom.wc.WooExperimentalNetwork
 import org.wordpress.android.fluxc.network.rest.wpcom.wc.WooNetwork
 import org.wordpress.android.fluxc.network.rest.wpcom.wc.WooPayload
 import org.wordpress.android.fluxc.network.rest.wpcom.wc.order.OrderDto.Billing
@@ -64,7 +63,6 @@ class OrderRestClient @Inject constructor(
     private val dispatcher: Dispatcher,
     private val orderDtoMapper: OrderDtoMapper,
     private val wooNetwork: WooNetwork,
-    private val wooExperimentalNetwork: WooExperimentalNetwork,
     private val coroutineEngine: CoroutineEngine
 ) {
     /**
@@ -108,6 +106,7 @@ class OrderRestClient @Inject constructor(
                     )
                     dispatcher.dispatch(WCOrderActionBuilder.newFetchedOrdersAction(payload))
                 }
+
                 is WPAPIResponse.Error -> {
                     val orderError = wpAPINetworkErrorToOrderError(response.error)
                     val payload = FetchOrdersResponsePayload(orderError, site)
@@ -212,6 +211,7 @@ class OrderRestClient @Inject constructor(
                     canLoadMore = canLoadMore
                 )
             }
+
             is WPAPIResponse.Error -> {
                 val orderError = wpAPINetworkErrorToOrderError(response.error)
                 return FetchOrdersResponsePayload(orderError, site)
@@ -236,8 +236,7 @@ class OrderRestClient @Inject constructor(
     @Suppress("LongMethod")
     fun fetchOrderListSummaries(
         listDescriptor: WCOrderListDescriptor,
-        offset: Long,
-        useAppPasswordsForJetpackSites: Boolean
+        offset: Long
     ) {
         coroutineEngine.launch(T.API, this, "fetchOrderListSummaries") {
             val startTime = System.currentTimeMillis()
@@ -258,13 +257,7 @@ class OrderRestClient @Inject constructor(
                 "created_via" to listDescriptor.createdViaFilter.takeUnless { it.isNullOrBlank() }
             )
 
-            val network = if (useAppPasswordsForJetpackSites) {
-                wooExperimentalNetwork
-            } else {
-                wooNetwork
-            }
-
-            val response = network.executeGetGsonRequest(
+            val response = wooNetwork.executeGetGsonRequest(
                 site = listDescriptor.site,
                 path = url,
                 clazz = Array<OrderSummaryApiResponse>::class.java,
@@ -289,6 +282,7 @@ class OrderRestClient @Inject constructor(
                     )
                     dispatcher.dispatch(WCOrderActionBuilder.newFetchedOrderListAction(payload))
                 }
+
                 is WPAPIResponse.Error -> {
                     val orderError = wpAPINetworkErrorToOrderError(response.error)
                     val payload = FetchOrderListResponsePayload(
@@ -372,6 +366,7 @@ class OrderRestClient @Inject constructor(
                     )
                     dispatcher.dispatch(WCOrderActionBuilder.newFetchedOrdersByIdsAction(payload))
                 }
+
                 is WPAPIResponse.Error -> {
                     val orderError = wpAPINetworkErrorToOrderError(response.error)
                     val payload = FetchOrdersByIdsResponsePayload(
@@ -418,6 +413,7 @@ class OrderRestClient @Inject constructor(
                         WCOrderActionBuilder.newFetchedOrderStatusOptionsAction(payload)
                     )
                 }
+
                 is WPAPIResponse.Error -> {
                     val orderError = wpAPINetworkErrorToOrderError(response.error)
                     val payload = FetchOrderStatusOptionsResponsePayload(orderError, site)
@@ -473,6 +469,7 @@ class OrderRestClient @Inject constructor(
                     )
                     dispatcher.dispatch(WCOrderActionBuilder.newSearchedOrdersAction(payload))
                 }
+
                 is WPAPIResponse.Error -> {
                     val orderError = wpAPINetworkErrorToOrderError(response.error)
                     val payload = SearchOrdersResponsePayload(orderError, site, searchQuery)
@@ -512,6 +509,7 @@ class OrderRestClient @Inject constructor(
                     site
                 )
             }
+
             is WPAPIResponse.Error -> {
                 val orderError = wpAPINetworkErrorToOrderError(response.error)
                 RemoteOrderPayload.Fetching(
@@ -536,8 +534,10 @@ class OrderRestClient @Inject constructor(
      */
     fun fetchOrderCountSync(site: SiteModel, filterByStatus: String) {
         coroutineEngine.launch(T.API, this, "fetchOrderCount") {
-            dispatcher.dispatch(WCOrderActionBuilder.newFetchedOrdersCountAction(
-                doFetchOrderCount(site, filterByStatus))
+            dispatcher.dispatch(
+                WCOrderActionBuilder.newFetchedOrdersCountAction(
+                    doFetchOrderCount(site, filterByStatus)
+                )
             )
         }
     }
@@ -589,6 +589,7 @@ class OrderRestClient @Inject constructor(
                     site
                 )
             }
+
             is WPAPIResponse.Error -> {
                 val orderError = wpAPINetworkErrorToOrderError(response.error)
                 FetchHasOrdersResponsePayload(
@@ -631,6 +632,7 @@ class OrderRestClient @Inject constructor(
                     site
                 )
             }
+
             is WPAPIResponse.Error -> {
                 val orderError = wpAPINetworkErrorToOrderError(response.error)
                 RemoteOrderPayload.Updating(
@@ -660,10 +662,10 @@ class OrderRestClient @Inject constructor(
         paymentDetails?.cashPaymentChangeDueAmount?.let {
             val metaData = mapOf(
                 "meta_data" to listOfNotNull(
-                        mapOf(
-                            "key" to "_cash_change_amount",
-                            "value" to it
-                        )
+                    mapOf(
+                        "key" to "_cash_change_amount",
+                        "value" to it
+                    )
                 )
             )
 
@@ -789,6 +791,7 @@ class OrderRestClient @Inject constructor(
 
                 FetchOrderShipmentTrackingsResponsePayload(site, orderId, trackings)
             }
+
             is WPAPIResponse.Error -> {
                 val trackingsError = wpAPINetworkErrorToOrderError(response.error)
                 FetchOrderShipmentTrackingsResponsePayload(trackingsError, site, orderId)
@@ -845,6 +848,7 @@ class OrderRestClient @Inject constructor(
                     tracking
                 )
             }
+
             is WPAPIResponse.Error -> {
                 val trackingsError = wpAPINetworkErrorToOrderError(response.error)
                 AddOrderShipmentTrackingResponsePayload(trackingsError, site, orderId, tracking)
@@ -894,6 +898,7 @@ class OrderRestClient @Inject constructor(
                     tracking
                 )
             }
+
             is WPAPIResponse.Error -> DeleteOrderShipmentTrackingResponsePayload(
                 wpAPINetworkErrorToOrderError(response.error),
                 site,
@@ -1124,16 +1129,16 @@ class OrderRestClient @Inject constructor(
     }
 
     /**
-    * Performs a batch update of order statuses via the WooCommerce REST API.
-    *
-    * This endpoint enables updating multiple orders to the same status in a single network request.
-    * The WooCommerce API has a limit of 100 orders per batch update.
-    *
-    * @param site The site to perform the update on
-    * @param orderIds List of order IDs to update. Error if exceeds [BATCH_UPDATE_LIMIT]
-    * @param newStatus The new status to set for all specified orders
-    * @return [BulkUpdateOrderStatusResponsePayload] containing either the update results or an error
-    */
+     * Performs a batch update of order statuses via the WooCommerce REST API.
+     *
+     * This endpoint enables updating multiple orders to the same status in a single network request.
+     * The WooCommerce API has a limit of 100 orders per batch update.
+     *
+     * @param site The site to perform the update on
+     * @param orderIds List of order IDs to update. Error if exceeds [BATCH_UPDATE_LIMIT]
+     * @param newStatus The new status to set for all specified orders
+     * @return [BulkUpdateOrderStatusResponsePayload] containing either the update results or an error
+     */
     suspend fun batchUpdateOrdersStatus(
         site: SiteModel,
         orderIds: List<Long>,
@@ -1201,7 +1206,10 @@ class OrderRestClient @Inject constructor(
         }
     }
 
-    private fun orderResponseToOrderSummaryModel(response: OrderSummaryApiResponse, siteId: LocalId): WCOrderSummaryModel {
+    private fun orderResponseToOrderSummaryModel(
+        response: OrderSummaryApiResponse,
+        siteId: LocalId
+    ): WCOrderSummaryModel {
         return WCOrderSummaryModel(
             siteId = siteId,
             orderId = RemoteId(response.id ?: 0),
diff --git a/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/store/WCOrderStore.kt b/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/store/WCOrderStore.kt
index 48ce91c6ed50..5f31bce5390c 100644
--- a/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/store/WCOrderStore.kt
+++ b/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/store/WCOrderStore.kt
@@ -84,8 +84,7 @@ class WCOrderStore @Inject internal constructor(
 
     class FetchOrderListPayload(
         val listDescriptor: WCOrderListDescriptor,
-        val offset: Long,
-        val useAppPasswordsForJetpackSites: Boolean
+        val offset: Long
     ) : Payload<BaseNetworkError>()
 
     class FetchOrdersByIdsPayload(
@@ -504,7 +503,7 @@ class WCOrderStore @Inject internal constructor(
      * Returns the notes belonging to supplied [OrderEntity] as a list of [OrderNoteEntity].
      */
     suspend fun getOrderNotesForOrder(site: SiteModel, orderId: Long): List<OrderNoteEntity> =
-            orderNotesDao.queryNotesOfOrder(localSiteId = site.localId(), orderId = RemoteId(orderId))
+        orderNotesDao.queryNotesOfOrder(localSiteId = site.localId(), orderId = RemoteId(orderId))
 
     /**
      * Returns the order status options available for the provided site [SiteModel] as a list of [WCOrderStatusModel].
@@ -539,6 +538,7 @@ class WCOrderStore @Inject internal constructor(
             WCOrderAction.FETCH_ORDERS_COUNT -> fetchOrdersCount(action.payload as FetchOrdersCountPayload)
             WCOrderAction.UPDATE_ORDER_STATUS ->
                 throw IllegalStateException("Invalid action. Use suspendable updateOrderStatus(..) directly")
+
             WCOrderAction.SEARCH_ORDERS -> searchOrders(action.payload as SearchOrdersPayload)
             WCOrderAction.FETCH_ORDER_STATUS_OPTIONS ->
                 fetchOrderStatusOptions(action.payload as FetchOrderStatusOptionsPayload)
@@ -547,10 +547,13 @@ class WCOrderStore @Inject internal constructor(
             WCOrderAction.FETCHED_ORDERS -> handleFetchOrdersCompleted(action.payload as FetchOrdersResponsePayload)
             WCOrderAction.FETCHED_ORDER_LIST ->
                 handleFetchOrderListCompleted(action.payload as FetchOrderListResponsePayload)
+
             WCOrderAction.FETCHED_ORDERS_BY_IDS ->
                 handleFetchOrderByIdsCompleted(action.payload as FetchOrdersByIdsResponsePayload)
+
             WCOrderAction.FETCHED_ORDERS_COUNT ->
                 handleFetchOrdersCountCompleted(action.payload as FetchOrdersCountResponsePayload)
+
             WCOrderAction.SEARCHED_ORDERS -> handleSearchOrdersCompleted(action.payload as SearchOrdersResponsePayload)
             WCOrderAction.FETCHED_ORDER_STATUS_OPTIONS ->
                 handleFetchOrderStatusOptionsCompleted(action.payload as FetchOrderStatusOptionsResponsePayload)
@@ -569,8 +572,7 @@ class WCOrderStore @Inject internal constructor(
     private fun fetchOrderList(payload: FetchOrderListPayload) {
         wcOrderRestClient.fetchOrderListSummaries(
             listDescriptor = payload.listDescriptor,
-            offset = payload.offset,
-            useAppPasswordsForJetpackSites = payload.useAppPasswordsForJetpackSites
+            offset = payload.offset
         )
     }
 
@@ -592,7 +594,7 @@ class WCOrderStore @Inject internal constructor(
         return coroutineEngine.withDefaultContext(API, this, "checkIfHasOrders") {
             val result = wcOrderRestClient.fetchOrderCountSync(site, filterByStatus)
             return@withDefaultContext if (result.isError) {
-                 OrdersCountResult.Failure(result.error)
+                OrdersCountResult.Failure(result.error)
             } else {
                 OrdersCountResult.Success(result.count)
             }
@@ -972,7 +974,9 @@ class WCOrderStore @Inject internal constructor(
             )
         )
 
-        mDispatcher.dispatch(ListActionBuilder.newFetchedListItemsAction(FetchedListItemsPayload(
+        mDispatcher.dispatch(
+            ListActionBuilder.newFetchedListItemsAction(
+            FetchedListItemsPayload(
             listDescriptor = payload.listDescriptor,
             remoteItemIds = payload.orderSummaries.map { it.orderId.value },
             loadedMore = payload.loadedMore,
@@ -1054,12 +1058,12 @@ class WCOrderStore @Inject internal constructor(
 
                 mDispatcher.dispatch(
                     ListActionBuilder.newListDataFailureAction(
-                            OnListDataFailure(listTypeIdentifier).apply {
-                                error = ListError(
-                                    errorType,
-                                    payload.error.message
-                                )
-                            }
+                        OnListDataFailure(listTypeIdentifier).apply {
+                            error = ListError(
+                                errorType,
+                                payload.error.message
+                            )
+                        }
                     )
                 )
             }
diff --git a/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/store/WooCommerceStore.kt b/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/store/WooCommerceStore.kt
index 3f38c3883045..98673af4a7da 100644
--- a/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/store/WooCommerceStore.kt
+++ b/libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/store/WooCommerceStore.kt
@@ -41,7 +41,6 @@ import org.wordpress.android.fluxc.persistence.entity.WCSettingsModel
 import org.wordpress.android.fluxc.store.SiteStore.FetchSitesPayload
 import org.wordpress.android.fluxc.store.SiteStore.OnSiteChanged
 import org.wordpress.android.fluxc.tools.CoroutineEngine
-import org.wordpress.android.fluxc.utils.PreferenceUtils
 import org.wordpress.android.fluxc.utils.WCCurrencyUtils
 import org.wordpress.android.util.AppLog
 import org.wordpress.android.util.AppLog.T
@@ -109,23 +108,6 @@ open class WooCommerceStore @Inject internal constructor(
 
     @Suppress("ReturnCount")
     suspend fun fetchWooCommerceSite(site: SiteModel): WooResult<SiteModel> {
-        // Check if the site supports application passwords or not
-        // TODO remove this check after finishing the application passwords experiment
-        suspend fun fetchAppPasswordsSupportIfNeeded(site: SiteModel) {
-            val sharedPrefs = PreferenceUtils.getFluxCPreferences(appContext)
-            val sharedPrefKey = "application_passwords_check_done"
-            val checkDone = sharedPrefs.getBoolean(sharedPrefKey, false)
-            if (site.applicationPasswordsAuthorizeUrl != null || checkDone) return
-
-            fetchSupportedApiVersion(site, false).let {
-                if (!it.isError) {
-                    sharedPrefs.edit()
-                        .putBoolean(sharedPrefKey, true)
-                        .apply()
-                }
-            }
-        }
-
         val fetchResult = siteStore.fetchSite(site)
 
         val updatedSite = withContext(Dispatchers.IO) {
@@ -142,8 +124,6 @@ open class WooCommerceStore @Inject internal constructor(
             emitChange(OnSiteChanged(1, listOf(updatedSite)))
         }
 
-        fetchAppPasswordsSupportIfNeeded(updatedSite)
-
         return WooResult(updatedSite)
     }
 
diff --git a/libs/fluxc-plugin/src/test/java/org/wordpress/android/fluxc/network/rest/wpcom/wc/order/OrderRestClientTest.kt b/libs/fluxc-plugin/src/test/java/org/wordpress/android/fluxc/network/rest/wpcom/wc/order/OrderRestClientTest.kt
index b66c34cc5f95..4aec7de3a92a 100644
--- a/libs/fluxc-plugin/src/test/java/org/wordpress/android/fluxc/network/rest/wpcom/wc/order/OrderRestClientTest.kt
+++ b/libs/fluxc-plugin/src/test/java/org/wordpress/android/fluxc/network/rest/wpcom/wc/order/OrderRestClientTest.kt
@@ -16,7 +16,6 @@ import org.wordpress.android.fluxc.generated.endpoint.WOOCOMMERCE
 import org.wordpress.android.fluxc.model.SiteModel
 import org.wordpress.android.fluxc.model.WCOrderListDescriptor
 import org.wordpress.android.fluxc.network.rest.wpapi.WPAPIResponse
-import org.wordpress.android.fluxc.network.rest.wpcom.wc.WooExperimentalNetwork
 import org.wordpress.android.fluxc.network.rest.wpcom.wc.WooNetwork
 import org.wordpress.android.fluxc.tools.CoroutineEngine
 import org.wordpress.android.fluxc.utils.initCoroutineEngine
@@ -25,7 +24,6 @@ import kotlin.collections.emptyList
 @OptIn(ExperimentalCoroutinesApi::class)
 class OrderRestClientTest {
     private val wooNetwork: WooNetwork = mock()
-    private val wooExperimentalNetwork: WooExperimentalNetwork = mock()
     private val dispatcher: Dispatcher = mock()
     private val orderDtoMapper: OrderDtoMapper = mock()
     private val coroutineEngine: CoroutineEngine = initCoroutineEngine()
@@ -39,7 +37,6 @@ class OrderRestClientTest {
             dispatcher = dispatcher,
             orderDtoMapper = orderDtoMapper,
             wooNetwork = wooNetwork,
-            wooExperimentalNetwork = wooExperimentalNetwork,
             coroutineEngine = coroutineEngine
         )
     }
@@ -76,7 +73,7 @@ class OrderRestClientTest {
         )
 
         // When
-        orderRestClient.fetchOrderListSummaries(listDescriptor, 0, false)
+        orderRestClient.fetchOrderListSummaries(listDescriptor, 0)
 
         // Then
         val paramsCaptor = argumentCaptor<Map<String, String>>()
@@ -120,7 +117,7 @@ class OrderRestClientTest {
         )
 
         // When
-        orderRestClient.fetchOrderListSummaries(listDescriptor, 0, false)
+        orderRestClient.fetchOrderListSummaries(listDescriptor, 0)
 
         // Then
         val paramsCaptor = argumentCaptor<Map<String, String>>()
@@ -164,7 +161,7 @@ class OrderRestClientTest {
         )
 
         // When
-        orderRestClient.fetchOrderListSummaries(listDescriptor, 0, false)
+        orderRestClient.fetchOrderListSummaries(listDescriptor, 0)
 
         // Then
         val paramsCaptor = argumentCaptor<Map<String, String>>()
diff --git a/libs/fluxc-tests/src/test/java/org/wordpress/android/fluxc/network/rest/wpcom/wc/WooExperimentalNetworkTest.kt b/libs/fluxc-tests/src/test/java/org/wordpress/android/fluxc/network/rest/wpcom/wc/WooNetworkTest.kt
similarity index 74%
rename from libs/fluxc-tests/src/test/java/org/wordpress/android/fluxc/network/rest/wpcom/wc/WooExperimentalNetworkTest.kt
rename to libs/fluxc-tests/src/test/java/org/wordpress/android/fluxc/network/rest/wpcom/wc/WooNetworkTest.kt
index fc423654d309..206dfde7eeee 100644
--- a/libs/fluxc-tests/src/test/java/org/wordpress/android/fluxc/network/rest/wpcom/wc/WooExperimentalNetworkTest.kt
+++ b/libs/fluxc-tests/src/test/java/org/wordpress/android/fluxc/network/rest/wpcom/wc/WooNetworkTest.kt
@@ -11,25 +11,27 @@ import org.robolectric.RobolectricTestRunner
 import org.wordpress.android.fluxc.model.SiteModel
 import org.wordpress.android.fluxc.network.rest.wpapi.WPAPINetworkError
 import org.wordpress.android.fluxc.network.rest.wpapi.WPAPIResponse
+import org.wordpress.android.fluxc.network.rest.wpapi.applicationpasswords.ApplicationPasswordsConfiguration
 import org.wordpress.android.fluxc.network.rest.wpapi.applicationpasswords.ApplicationPasswordsNetwork
-import org.wordpress.android.fluxc.network.rest.wpapi.applicationpasswords.ApplicationPasswordsStore
 import org.wordpress.android.fluxc.network.rest.wpcom.JetpackTunnelWPAPINetwork
 import org.wordpress.android.fluxc.persistence.SiteSqlUtils
 import org.wordpress.android.fluxc.test
 
 @RunWith(RobolectricTestRunner::class)
-class WooExperimentalNetworkTest {
-    private val testSite = SiteModel()
+class WooNetworkTest {
+    private val testSite = SiteModel().apply {
+        url = "https://example.com"
+    }
     private val testPath = "path"
+    private val applicationPasswordsConfiguration = FakeApplicationPasswordsConfiguration()
     private val applicationPasswordsNetwork: ApplicationPasswordsNetwork = mock()
     private val jetpackTunnelWPAPINetwork: JetpackTunnelWPAPINetwork = mock()
-    private val applicationPasswordsStore: ApplicationPasswordsStore = mock()
     private val siteSqlUtils: SiteSqlUtils = mock()
 
-    private val sut = WooExperimentalNetwork(
+    private val sut = WooNetwork(
+        applicationPasswordsConfiguration = applicationPasswordsConfiguration,
         applicationPasswordsNetwork = applicationPasswordsNetwork,
         jetpackTunnelWPAPINetwork = jetpackTunnelWPAPINetwork,
-        applicationPasswordsStore = applicationPasswordsStore,
         siteSqlUtils = siteSqlUtils
     )
 
@@ -59,7 +61,14 @@ class WooExperimentalNetworkTest {
         test {
             testSite.origin = SiteModel.ORIGIN_WPCOM_REST
             testSite.applicationPasswordsAuthorizeUrl = "authorize_url"
-            givenAppPasswordsResponse(WPAPIResponse.Error(WPAPINetworkError(mock(), "error")))
+            givenAppPasswordsResponse(
+                WPAPIResponse.Error(
+                    WPAPINetworkError(
+                        mock(),
+                        "error"
+                    )
+                )
+            )
             val sampleResponse = SampleResponse("value")
             givenJetpackTunnelResponse(WPAPIResponse.Success(sampleResponse, emptyList()))
 
@@ -89,6 +98,28 @@ class WooExperimentalNetworkTest {
             assertThat((response as WPAPIResponse.Success).data).isEqualTo(sampleResponse)
         }
 
+    @Test
+    fun `when app passwords are disabled for jetpack access, then always use jetpack tunnel`() = test {
+        applicationPasswordsConfiguration.isEnabledForJetpackAccessValue = false
+        testSite.origin = SiteModel.ORIGIN_WPCOM_REST
+        testSite.applicationPasswordsAuthorizeUrl = "authorize_url"
+        val sampleResponse = SampleResponse("value")
+        givenJetpackTunnelResponse(WPAPIResponse.Success(sampleResponse, emptyList()))
+
+        val response = sut.executeGetGsonRequest(
+            site = testSite,
+            path = testPath,
+            clazz = SampleResponse::class.java
+        )
+
+        assertThat((response as WPAPIResponse.Success).data).isEqualTo(sampleResponse)
+        verify(applicationPasswordsNetwork, never()).executeGetGsonRequest(
+            site = testSite,
+            path = testPath,
+            clazz = SampleResponse::class.java
+        )
+    }
+
     @Test
     fun `when detecting that a site doesn't support app passwords, then update cached site with correct status`() =
         test {
@@ -139,4 +170,13 @@ class WooExperimentalNetworkTest {
     }
 
     private data class SampleResponse(val value: String)
+
+    private class FakeApplicationPasswordsConfiguration : ApplicationPasswordsConfiguration {
+        var isEnabledForJetpackAccessValue: Boolean = true
+
+        override val applicationName: String
+            get() = "WooCommerce"
+
+        override suspend fun isEnabledForJetpackAccess(): Boolean = isEnabledForJetpackAccessValue
+    }
 }
diff --git a/libs/fluxc/src/main/java/org/wordpress/android/fluxc/model/SiteModel.java b/libs/fluxc/src/main/java/org/wordpress/android/fluxc/model/SiteModel.java
index 8c75bd3950ae..da5447908b34 100644
--- a/libs/fluxc/src/main/java/org/wordpress/android/fluxc/model/SiteModel.java
+++ b/libs/fluxc/src/main/java/org/wordpress/android/fluxc/model/SiteModel.java
@@ -787,7 +787,7 @@ public void setOrigin(@SiteOrigin int origin) {
     }
 
     public boolean isUsingWpComRestApi() {
-        return isWPCom() || (isJetpackConnected() && getOrigin() == ORIGIN_WPCOM_REST);
+        return isWPCom() || getOrigin() == ORIGIN_WPCOM_REST;
     }
 
     public void setSpaceAvailable(long spaceAvailable) {
@@ -1090,7 +1090,7 @@ public void setApplicationPasswordsAuthorizeUrl(String applicationPasswordsAutho
 
     public boolean isApplicationPasswordsSupported() {
         return mApplicationPasswordsAuthorizeUrl != null &&
-!mApplicationPasswordsAuthorizeUrl.isEmpty();
+                !mApplicationPasswordsAuthorizeUrl.isEmpty();
     }
 
     public int getPublishedStatus() {
diff --git a/libs/fluxc/src/main/java/org/wordpress/android/fluxc/module/ApplicationPasswordsClientId.kt b/libs/fluxc/src/main/java/org/wordpress/android/fluxc/module/ApplicationPasswordsClientId.kt
deleted file mode 100644
index c1ac54e31ab5..000000000000
--- a/libs/fluxc/src/main/java/org/wordpress/android/fluxc/module/ApplicationPasswordsClientId.kt
+++ /dev/null
@@ -1,13 +0,0 @@
-package org.wordpress.android.fluxc.module
-
-import javax.inject.Qualifier
-import kotlin.annotation.AnnotationRetention.RUNTIME
-
-/**
- * Defines the name to use for naming the WordPress "application passwords" that the app
- * will create.
- */
-@Qualifier
-@MustBeDocumented
-@Retention(RUNTIME)
-annotation class ApplicationPasswordsClientId
diff --git a/libs/fluxc/src/main/java/org/wordpress/android/fluxc/module/ApplicationPasswordsModule.kt b/libs/fluxc/src/main/java/org/wordpress/android/fluxc/module/ApplicationPasswordsModule.kt
index 31137c3b456b..2779d6aa8da7 100644
--- a/libs/fluxc/src/main/java/org/wordpress/android/fluxc/module/ApplicationPasswordsModule.kt
+++ b/libs/fluxc/src/main/java/org/wordpress/android/fluxc/module/ApplicationPasswordsModule.kt
@@ -8,7 +8,4 @@ import org.wordpress.android.fluxc.network.rest.wpapi.applicationpasswords.Appli
 interface ApplicationPasswordsModule {
     @BindsOptionalOf
     fun bindOptionalApplicationPasswordsListener(): ApplicationPasswordsListener
-    @BindsOptionalOf
-    @ApplicationPasswordsClientId
-    fun bindOptionalApplicationPasswordsClientId(): String
 }
diff --git a/libs/fluxc/src/main/java/org/wordpress/android/fluxc/network/rest/wpapi/WPAPIResponse.kt b/libs/fluxc/src/main/java/org/wordpress/android/fluxc/network/rest/wpapi/WPAPIResponse.kt
index 7cb8578c9fd8..f1d6ee5f6d9b 100644
--- a/libs/fluxc/src/main/java/org/wordpress/android/fluxc/network/rest/wpapi/WPAPIResponse.kt
+++ b/libs/fluxc/src/main/java/org/wordpress/android/fluxc/network/rest/wpapi/WPAPIResponse.kt
@@ -17,8 +17,6 @@ sealed class WPAPIResponse<T> {
 
 /**
  * The networking mode that was used to make the request.
- *
- * This is used for tracking purposes, and used only with the Woo experimental networking mode.
  */
 sealed interface WPAPINetworkingMode {
     data object ApplicationPasswords : WPAPINetworkingMode
diff --git a/libs/fluxc/src/main/java/org/wordpress/android/fluxc/network/rest/wpapi/applicationpasswords/ApplicationPasswordsConfiguration.kt b/libs/fluxc/src/main/java/org/wordpress/android/fluxc/network/rest/wpapi/applicationpasswords/ApplicationPasswordsConfiguration.kt
index f58b792fcb5c..feaa4274ad6c 100644
--- a/libs/fluxc/src/main/java/org/wordpress/android/fluxc/network/rest/wpapi/applicationpasswords/ApplicationPasswordsConfiguration.kt
+++ b/libs/fluxc/src/main/java/org/wordpress/android/fluxc/network/rest/wpapi/applicationpasswords/ApplicationPasswordsConfiguration.kt
@@ -1,26 +1,17 @@
 package org.wordpress.android.fluxc.network.rest.wpapi.applicationpasswords
 
-import org.wordpress.android.fluxc.module.ApplicationPasswordsClientId
-import java.util.Optional
-import javax.inject.Inject
+interface ApplicationPasswordsConfiguration {
+    val applicationName: String
 
-/**
- * Note: the [ApplicationPasswordsClientId] is provided as [Optional] because we want to keep the feature optional and
- * to not force the client apps to provide it. With this change, we will keep Dagger happy, and we move from a compile
- * error to a runtime error if it's missing.
- */
-internal data class ApplicationPasswordsConfiguration @Inject constructor(
-    @ApplicationPasswordsClientId private val applicationNameOptional: Optional<String>
-) {
-    val isEnabled: Boolean
-        get() = applicationNameOptional.isPresent
+    /**
+     * Returns true if the Application Passwords feature is enabled for direct site access.
+     * This applies when sites are accessed using their URL directly (not through Jetpack).
+     */
+    fun isEnabledForDirectAccess(): Boolean = true
 
-    val applicationName: String
-        get() = applicationNameOptional.orElseThrow {
-            NoSuchElementException(
-                "Please make sure to inject a String instance with " +
-                    "the annotation @${ApplicationPasswordsClientId::class.simpleName} to the Dagger graph" +
-                    "to be able to use the Application Passwords feature"
-            )
-        }
+    /**
+     * Returns true if the Application Passwords feature is enabled for Jetpack-mediated access.
+     * This applies when sites are accessed through Jetpack, even if they are self-hosted.
+     */
+    suspend fun isEnabledForJetpackAccess(): Boolean
 }
diff --git a/libs/fluxc/src/main/java/org/wordpress/android/fluxc/network/rest/wpapi/applicationpasswords/ApplicationPasswordsStore.kt b/libs/fluxc/src/main/java/org/wordpress/android/fluxc/network/rest/wpapi/applicationpasswords/ApplicationPasswordsStore.kt
index 63ee495030a8..43a94805978f 100644
--- a/libs/fluxc/src/main/java/org/wordpress/android/fluxc/network/rest/wpapi/applicationpasswords/ApplicationPasswordsStore.kt
+++ b/libs/fluxc/src/main/java/org/wordpress/android/fluxc/network/rest/wpapi/applicationpasswords/ApplicationPasswordsStore.kt
@@ -39,7 +39,7 @@ class ApplicationPasswordsStore @Inject constructor(
         val uuid = encryptedPreferences.getString(site.uuidPrefKey, null)
 
         return when {
-            !site.isUsingWpComRestApi && site.username != username -> null
+            site.username != username && !site.isUsingWpComRestApi -> null
             username != null && password != null ->
                 ApplicationPasswordCredentials(
                     userName = username,
diff --git a/libs/fluxc/src/main/java/org/wordpress/android/fluxc/store/MediaStore.java b/libs/fluxc/src/main/java/org/wordpress/android/fluxc/store/MediaStore.java
index 8a269baf5ca1..4f7d64630628 100644
--- a/libs/fluxc/src/main/java/org/wordpress/android/fluxc/store/MediaStore.java
+++ b/libs/fluxc/src/main/java/org/wordpress/android/fluxc/store/MediaStore.java
@@ -801,7 +801,7 @@ private void performUploadMedia(@NonNull UploadMediaPayload payload) {
         if (payload.site.getOrigin() == SiteModel.ORIGIN_WPCOM_REST) {
             mWPComV2MediaRestClient.uploadMedia(payload.site, payload.media);
         } else if (payload.site.getOrigin() == SiteModel.ORIGIN_WPAPI
-                   && mApplicationPasswordsConfiguration.isEnabled()) {
+                   && mApplicationPasswordsConfiguration.isEnabledForDirectAccess()) {
             mApplicationPasswordsMediaRestClient.uploadMedia(payload.site, payload.media);
         } else {
             mMediaXmlrpcClient.uploadMedia(payload.site, payload.media);
@@ -823,7 +823,7 @@ private void performFetchMediaList(@NonNull FetchMediaListPayload payload) {
         if (payload.site.getOrigin() == SiteModel.ORIGIN_WPCOM_REST) {
             mWPComV2MediaRestClient.fetchMediaList(payload.site, payload.number, offset, payload.mimeType);
         } else if (payload.site.getOrigin() == SiteModel.ORIGIN_WPAPI
-                   && mApplicationPasswordsConfiguration.isEnabled()) {
+                   && mApplicationPasswordsConfiguration.isEnabledForDirectAccess()) {
             mApplicationPasswordsMediaRestClient.fetchMediaList(payload.site, payload.number, offset, payload.mimeType);
         } else {
             mMediaXmlrpcClient.fetchMediaList(payload.site, payload.number, offset, payload.mimeType);
@@ -869,7 +869,7 @@ private void performCancelUpload(@NonNull CancelMediaPayload payload) {
         if (payload.site.getOrigin() == SiteModel.ORIGIN_WPCOM_REST) {
             mWPComV2MediaRestClient.cancelUpload(media);
         } else if (payload.site.getOrigin() == SiteModel.ORIGIN_WPAPI
-                   && mApplicationPasswordsConfiguration.isEnabled()) {
+                   && mApplicationPasswordsConfiguration.isEnabledForDirectAccess()) {
             mApplicationPasswordsMediaRestClient.cancelUpload(media);
         } else {
             mMediaXmlrpcClient.cancelUpload(media);
diff --git a/libs/fluxc/src/test/java/org/wordpress/android/fluxc/network/rest/wpapi/applicationpasswords/ApplicationPasswordManagerTests.kt b/libs/fluxc/src/test/java/org/wordpress/android/fluxc/network/rest/wpapi/applicationpasswords/ApplicationPasswordManagerTests.kt
index 1c6c27e18751..2f691d359328 100644
--- a/libs/fluxc/src/test/java/org/wordpress/android/fluxc/network/rest/wpapi/applicationpasswords/ApplicationPasswordManagerTests.kt
+++ b/libs/fluxc/src/test/java/org/wordpress/android/fluxc/network/rest/wpapi/applicationpasswords/ApplicationPasswordManagerTests.kt
@@ -14,7 +14,6 @@ import org.wordpress.android.fluxc.model.SiteModel
 import org.wordpress.android.fluxc.network.BaseRequest.BaseNetworkError
 import org.wordpress.android.fluxc.network.BaseRequest.GenericErrorType
 import org.wordpress.android.fluxc.network.rest.wpcom.WPComGsonRequest.WPComGsonNetworkError
-import java.util.*
 import kotlin.test.assertEquals
 
 @ExperimentalCoroutinesApi
@@ -34,7 +33,10 @@ class ApplicationPasswordManagerTests {
     private val mJetpackApplicationPasswordsRestClient: JetpackApplicationPasswordsRestClient = mock()
     private val mWpApiApplicationPasswordsRestClient: WPApiApplicationPasswordsRestClient = mock()
 
-    private val applicationPasswordsConfiguration = ApplicationPasswordsConfiguration(Optional.of(applicationName))
+    private val applicationPasswordsConfiguration = object : ApplicationPasswordsConfiguration {
+        override val applicationName: String = this@ApplicationPasswordManagerTests.applicationName
+        override suspend fun isEnabledForJetpackAccess() = true
+    }
 
     private lateinit var mApplicationPasswordsManager: ApplicationPasswordsManager