diff --git a/CHANGELOG.unreleased.md b/CHANGELOG.unreleased.md
index 2037dbf8d57..d213e74bdf6 100644
--- a/CHANGELOG.unreleased.md
+++ b/CHANGELOG.unreleased.md
@@ -21,6 +21,7 @@ For upgrade instructions, please check the [migration guide](MIGRATIONS.released
 - Non-admin or -manager users can no longer start long-running jobs that create datasets. This includes annotation materialization and AI inferrals. [#7753](https://github.com/scalableminds/webknossos/pull/7753)
 - In the time tracking view, all annotations and tasks can be shown for each user by expanding the table. The individual time spans spent with a task or annotating an explorative annotation can be accessed via CSV export. The detail view including a chart for the individual spans has been removed. [#7733](https://github.com/scalableminds/webknossos/pull/7733)
 - Slightly refactored the `<FixExpandleTable/>`component to use columns as props. [#7772](https://github.com/scalableminds/webknossos/pull/7772)
+- The config value `datastore.localFolderWhitelist` can now be set for each datastore individually. [#7800](https://github.com/scalableminds/webknossos/pull/7800)
 
 ### Fixed
 - Fixed a bug where a toast that was reopened had a flickering effect during the reopening animation. [#7793](https://github.com/scalableminds/webknossos/pull/7793)
diff --git a/app/controllers/AnnotationIOController.scala b/app/controllers/AnnotationIOController.scala
index 71f51c3a548..fdd1c21437a 100755
--- a/app/controllers/AnnotationIOController.scala
+++ b/app/controllers/AnnotationIOController.scala
@@ -1,5 +1,7 @@
 package controllers
 
+import collections.SequenceUtils
+
 import java.io.{BufferedOutputStream, File, FileOutputStream}
 import java.util.zip.Deflater
 import org.apache.pekko.actor.ActorSystem
@@ -266,11 +268,7 @@ class AnnotationIOController @Inject()(
     }
 
   private def assertAllOnSameDataset(skeletons: List[SkeletonTracing], volumes: List[VolumeTracing]): Fox[String] =
-    for {
-      datasetName <- volumes.headOption.map(_.datasetName).orElse(skeletons.headOption.map(_.datasetName)).toFox
-      _ <- bool2Fox(skeletons.forall(_.datasetName == datasetName))
-      _ <- bool2Fox(volumes.forall(_.datasetName == datasetName))
-    } yield datasetName
+    SequenceUtils.findUniqueElement(volumes.map(_.datasetName) ++ skeletons.map(_.datasetName)).toFox
 
   private def assertAllOnSameOrganization(skeletons: List[SkeletonTracing],
                                           volumes: List[VolumeTracing]): Fox[Option[String]] = {
diff --git a/app/controllers/DatasetController.scala b/app/controllers/DatasetController.scala
index e644db6934f..c955e16257c 100755
--- a/app/controllers/DatasetController.scala
+++ b/app/controllers/DatasetController.scala
@@ -5,18 +5,17 @@ import com.scalableminds.util.accesscontext.{DBAccessContext, GlobalAccessContex
 import com.scalableminds.util.geometry.{BoundingBox, Vec3Int}
 import com.scalableminds.util.time.Instant
 import com.scalableminds.util.tools.{Fox, TristateOptionJsonHelper}
-import com.scalableminds.webknossos.datastore.models.datasource.{DataLayer, ElementClass, GenericDataSource}
+import com.scalableminds.webknossos.datastore.models.datasource.ElementClass
 import models.analytics.{AnalyticsService, ChangeDatasetSettingsEvent, OpenDatasetEvent}
 import models.dataset._
 import models.dataset.explore.{
   ExploreAndAddRemoteDatasetParameters,
-  ExploreRemoteDatasetParameters,
-  ExploreRemoteLayerService
+  WKExploreRemoteLayerParameters,
+  WKExploreRemoteLayerService
 }
 import models.organization.OrganizationDAO
 import models.team.{TeamDAO, TeamService}
 import models.user.{User, UserDAO, UserService}
-import net.liftweb.common.{Box, Empty, Failure, Full}
 import play.api.i18n.{Messages, MessagesProvider}
 import play.api.libs.functional.syntax._
 import play.api.libs.json._
@@ -24,7 +23,6 @@ import play.api.mvc.{Action, AnyContent, PlayBodyParsers}
 import utils.{ObjectId, WkConf}
 
 import javax.inject.Inject
-import scala.collection.mutable.ListBuffer
 import scala.concurrent.{ExecutionContext, Future}
 import com.scalableminds.webknossos.datastore.models.AdditionalCoordinate
 import mail.{MailchimpClient, MailchimpTag}
@@ -71,7 +69,7 @@ class DatasetController @Inject()(userService: UserService,
                                   conf: WkConf,
                                   analyticsService: AnalyticsService,
                                   mailchimpClient: MailchimpClient,
-                                  exploreRemoteLayerService: ExploreRemoteLayerService,
+                                  wkExploreRemoteLayerService: WKExploreRemoteLayerService,
                                   sil: Silhouette[WkEnv])(implicit ec: ExecutionContext, bodyParsers: PlayBodyParsers)
     extends Controller {
 
@@ -107,46 +105,29 @@ class DatasetController @Inject()(userService: UserService,
       }
     }
 
-  def exploreRemoteDataset(): Action[List[ExploreRemoteDatasetParameters]] =
-    sil.SecuredAction.async(validateJson[List[ExploreRemoteDatasetParameters]]) { implicit request =>
-      val reportMutable = ListBuffer[String]()
+  def exploreRemoteDataset(): Action[List[WKExploreRemoteLayerParameters]] =
+    sil.SecuredAction.async(validateJson[List[WKExploreRemoteLayerParameters]]) { implicit request =>
       for {
-        dataSourceBox: Box[GenericDataSource[DataLayer]] <- exploreRemoteLayerService
-          .exploreRemoteDatasource(request.body, request.identity, reportMutable)
-          .futureBox
-        dataSourceOpt = dataSourceBox match {
-          case Full(dataSource) if dataSource.dataLayers.nonEmpty =>
-            reportMutable += s"Resulted in dataSource with ${dataSource.dataLayers.length} layers."
-            Some(dataSource)
-          case Full(_) =>
-            reportMutable += "Error when exploring as layer set: Resulted in zero layers."
-            None
-          case f: Failure =>
-            reportMutable += s"Error when exploring as layer set: ${Fox.failureChainAsString(f)}"
-            None
-          case Empty =>
-            reportMutable += "Error when exploring as layer set: Empty"
-            None
-        }
-      } yield Ok(Json.obj("dataSource" -> Json.toJson(dataSourceOpt), "report" -> reportMutable.mkString("\n")))
+        exploreResponse <- wkExploreRemoteLayerService.exploreRemoteDatasource(request.body, request.identity)
+      } yield Ok(Json.toJson(exploreResponse))
     }
 
   // Note: This route is used by external applications, keep stable
   def exploreAndAddRemoteDataset(): Action[ExploreAndAddRemoteDatasetParameters] =
     sil.SecuredAction.async(validateJson[ExploreAndAddRemoteDatasetParameters]) { implicit request =>
-      val reportMutable = ListBuffer[String]()
-      val adaptedParameters = ExploreRemoteDatasetParameters(request.body.remoteUri, None, None, None)
+      val adaptedParameters =
+        WKExploreRemoteLayerParameters(request.body.remoteUri, None, None, None, request.body.dataStoreName)
       for {
-        dataSource <- exploreRemoteLayerService.exploreRemoteDatasource(List(adaptedParameters),
-                                                                        request.identity,
-                                                                        reportMutable)
+        exploreResponse <- wkExploreRemoteLayerService.exploreRemoteDatasource(List(adaptedParameters),
+                                                                               request.identity)
+        dataSource <- exploreResponse.dataSource ?~> "dataset.explore.failed"
         _ <- bool2Fox(dataSource.dataLayers.nonEmpty) ?~> "dataset.explore.zeroLayers"
         folderIdOpt <- Fox.runOptional(request.body.folderPath)(folderPath =>
           folderService.getOrCreateFromPathLiteral(folderPath, request.identity._organization)) ?~> "dataset.explore.autoAdd.getFolder.failed"
-        _ <- exploreRemoteLayerService.addRemoteDatasource(dataSource,
-                                                           request.body.datasetName,
-                                                           request.identity,
-                                                           folderIdOpt) ?~> "dataset.explore.autoAdd.failed"
+        _ <- wkExploreRemoteLayerService.addRemoteDatasource(dataSource,
+                                                             request.body.datasetName,
+                                                             request.identity,
+                                                             folderIdOpt) ?~> "dataset.explore.autoAdd.failed"
       } yield Ok
     }
 
diff --git a/app/models/dataset/WKRemoteDataStoreClient.scala b/app/models/dataset/WKRemoteDataStoreClient.scala
index db14f13ed57..7015bd4d90d 100644
--- a/app/models/dataset/WKRemoteDataStoreClient.scala
+++ b/app/models/dataset/WKRemoteDataStoreClient.scala
@@ -3,6 +3,11 @@ package models.dataset
 import com.scalableminds.util.cache.AlfuCache
 import com.scalableminds.util.geometry.{BoundingBox, Vec3Int}
 import com.scalableminds.util.tools.Fox
+import com.scalableminds.webknossos.datastore.explore.{
+  ExploreRemoteDatasetRequest,
+  ExploreRemoteDatasetResponse,
+  ExploreRemoteLayerParameters
+}
 import com.scalableminds.webknossos.datastore.models.{AdditionalCoordinate, RawCuboidRequest}
 import com.scalableminds.webknossos.datastore.models.datasource.{DataLayer, GenericDataSource}
 import com.scalableminds.webknossos.datastore.rpc.RPC
@@ -102,4 +107,12 @@ class WKRemoteDataStoreClient(dataStore: DataStore, rpc: RPC) extends LazyLoggin
     )
   }
 
+  def exploreRemoteDataset(layerParameters: List[ExploreRemoteLayerParameters],
+                           organizationName: String,
+                           userToken: String): Fox[ExploreRemoteDatasetResponse] =
+    rpc(s"${dataStore.url}/data/datasets/exploreRemote")
+      .addQueryString("token" -> userToken)
+      .postJsonWithJsonResponse[ExploreRemoteDatasetRequest, ExploreRemoteDatasetResponse](
+        ExploreRemoteDatasetRequest(layerParameters, organizationName))
+
 }
diff --git a/app/models/dataset/explore/ExploreRemoteLayerService.scala b/app/models/dataset/explore/ExploreRemoteLayerService.scala
deleted file mode 100644
index cec4dcfdae2..00000000000
--- a/app/models/dataset/explore/ExploreRemoteLayerService.scala
+++ /dev/null
@@ -1,167 +0,0 @@
-package models.dataset.explore
-
-import com.scalableminds.util.accesscontext.DBAccessContext
-import com.scalableminds.util.geometry.{Vec3Double, Vec3Int}
-import com.scalableminds.util.tools.{Fox, FoxImplicits}
-import com.scalableminds.webknossos.datastore.datavault.VaultPath
-import com.scalableminds.webknossos.datastore.explore.{
-  ExploreLayerService,
-  N5ArrayExplorer,
-  N5MultiscalesExplorer,
-  NeuroglancerUriExplorer,
-  NgffExplorer,
-  PrecomputedExplorer,
-  RemoteLayerExplorer,
-  WebknossosZarrExplorer,
-  Zarr3ArrayExplorer,
-  ZarrArrayExplorer
-}
-import com.scalableminds.webknossos.datastore.models.datasource._
-import com.scalableminds.webknossos.datastore.rpc.RPC
-import com.scalableminds.webknossos.datastore.storage.{DataVaultService, RemoteSourceDescriptor}
-import com.typesafe.scalalogging.LazyLogging
-import models.dataset.{DataStoreDAO, DatasetService, WKRemoteDataStoreClient}
-import models.dataset.credential.CredentialService
-import models.organization.OrganizationDAO
-import models.user.User
-import net.liftweb.common.{Empty, Failure, Full}
-import net.liftweb.common.Box.tryo
-import play.api.libs.json.{Json, OFormat}
-import security.{WkEnv, WkSilhouetteEnvironment}
-import utils.{ObjectId, WkConf}
-
-import java.net.URI
-import javax.inject.Inject
-import scala.collection.mutable.ListBuffer
-import scala.concurrent.ExecutionContext
-
-case class ExploreRemoteDatasetParameters(remoteUri: String,
-                                          credentialIdentifier: Option[String],
-                                          credentialSecret: Option[String],
-                                          preferredVoxelSize: Option[Vec3Double])
-
-object ExploreRemoteDatasetParameters {
-  implicit val jsonFormat: OFormat[ExploreRemoteDatasetParameters] = Json.format[ExploreRemoteDatasetParameters]
-}
-
-case class ExploreAndAddRemoteDatasetParameters(remoteUri: String, datasetName: String, folderPath: Option[String])
-
-object ExploreAndAddRemoteDatasetParameters {
-  implicit val jsonFormat: OFormat[ExploreAndAddRemoteDatasetParameters] =
-    Json.format[ExploreAndAddRemoteDatasetParameters]
-}
-
-class ExploreRemoteLayerService @Inject()(credentialService: CredentialService,
-                                          dataVaultService: DataVaultService,
-                                          organizationDAO: OrganizationDAO,
-                                          dataStoreDAO: DataStoreDAO,
-                                          datasetService: DatasetService,
-                                          wkSilhouetteEnvironment: WkSilhouetteEnvironment,
-                                          exploreLayerService: ExploreLayerService,
-                                          rpc: RPC,
-                                          wkConf: WkConf)
-    extends FoxImplicits
-    with LazyLogging {
-
-  private lazy val bearerTokenService = wkSilhouetteEnvironment.combinedAuthenticatorService.tokenAuthenticatorService
-
-  def exploreRemoteDatasource(
-      parameters: List[ExploreRemoteDatasetParameters],
-      requestIdentity: WkEnv#I,
-      reportMutable: ListBuffer[String])(implicit ec: ExecutionContext): Fox[GenericDataSource[DataLayer]] =
-    for {
-      exploredLayersNested <- Fox.serialCombined(parameters)(
-        parameters =>
-          exploreRemoteLayersForUri(parameters.remoteUri,
-                                    parameters.credentialIdentifier,
-                                    parameters.credentialSecret,
-                                    reportMutable,
-                                    requestIdentity))
-      layersWithVoxelSizes = exploredLayersNested.flatten
-      preferredVoxelSize = parameters.flatMap(_.preferredVoxelSize).headOption
-      _ <- bool2Fox(layersWithVoxelSizes.nonEmpty) ?~> "Detected zero layers"
-      (layers, voxelSize) <- exploreLayerService.adaptLayersAndVoxelSize(layersWithVoxelSizes, preferredVoxelSize)
-      dataSource = GenericDataSource[DataLayer](
-        DataSourceId("", ""), // Frontend will prompt user for a good name
-        layers,
-        voxelSize
-      )
-    } yield dataSource
-
-  def addRemoteDatasource(dataSource: GenericDataSource[DataLayer],
-                          datasetName: String,
-                          user: User,
-                          folderId: Option[ObjectId])(implicit ctx: DBAccessContext): Fox[Unit] =
-    for {
-      organization <- organizationDAO.findOne(user._organization)
-      dataStore <- dataStoreDAO.findOneWithUploadsAllowed
-      _ <- datasetService.assertValidDatasetName(datasetName)
-      _ <- datasetService.assertNewDatasetName(datasetName, organization._id) ?~> "dataset.name.alreadyTaken"
-      client = new WKRemoteDataStoreClient(dataStore, rpc)
-      userToken <- bearerTokenService.createAndInitDataStoreTokenForUser(user)
-      _ <- client.addDataSource(organization.name, datasetName, dataSource, folderId, userToken)
-    } yield ()
-
-  private def exploreRemoteLayersForUri(
-      layerUri: String,
-      credentialIdentifier: Option[String],
-      credentialSecret: Option[String],
-      reportMutable: ListBuffer[String],
-      requestingUser: User)(implicit ec: ExecutionContext): Fox[List[(DataLayerWithMagLocators, Vec3Double)]] =
-    for {
-      uri <- tryo(new URI(exploreLayerService.removeHeaderFileNamesFromUriSuffix(layerUri))) ?~> s"Received invalid URI: $layerUri"
-      _ <- bool2Fox(uri.getScheme != null) ?~> s"Received invalid URI: $layerUri"
-      _ <- assertLocalPathInWhitelist(uri)
-      credentialOpt = credentialService.createCredentialOpt(uri,
-                                                            credentialIdentifier,
-                                                            credentialSecret,
-                                                            requestingUser._id,
-                                                            requestingUser._organization)
-      remoteSource = RemoteSourceDescriptor(uri, credentialOpt)
-      credentialId <- Fox.runOptional(credentialOpt)(c => credentialService.insertOne(c)) ?~> "dataVault.credential.insert.failed"
-      remotePath <- dataVaultService.getVaultPath(remoteSource) ?~> "dataVault.setup.failed"
-      layersWithVoxelSizes <- exploreRemoteLayersForRemotePath(
-        remotePath,
-        credentialId.map(_.toString),
-        reportMutable,
-        List(
-          new ZarrArrayExplorer(Vec3Int.ones, ec),
-          new NgffExplorer,
-          new WebknossosZarrExplorer,
-          new N5ArrayExplorer,
-          new N5MultiscalesExplorer,
-          new PrecomputedExplorer,
-          new Zarr3ArrayExplorer,
-          new NeuroglancerUriExplorer(dataVaultService, exploreLayerService, ec)
-        )
-      )
-    } yield layersWithVoxelSizes
-
-  private def assertLocalPathInWhitelist(uri: URI)(implicit ec: ExecutionContext): Fox[Unit] =
-    if (uri.getScheme == DataVaultService.schemeFile) {
-      bool2Fox(wkConf.Datastore.localFolderWhitelist.exists(whitelistEntry => uri.getPath.startsWith(whitelistEntry))) ?~> s"Absolute path ${uri.getPath} in local file system is not in path whitelist. Consider adding it to datastore.localFolderWhitelist"
-    } else Fox.successful(())
-
-  private def exploreRemoteLayersForRemotePath(remotePath: VaultPath,
-                                               credentialId: Option[String],
-                                               reportMutable: ListBuffer[String],
-                                               explorers: List[RemoteLayerExplorer])(
-      implicit ec: ExecutionContext): Fox[List[(DataLayerWithMagLocators, Vec3Double)]] =
-    explorers match {
-      case Nil => Fox.empty
-      case currentExplorer :: remainingExplorers =>
-        reportMutable += s"\nTrying to explore $remotePath as ${currentExplorer.name}..."
-        currentExplorer.explore(remotePath, credentialId).futureBox.flatMap {
-          case Full(layersWithVoxelSizes) =>
-            reportMutable += s"Found ${layersWithVoxelSizes.length} ${currentExplorer.name} layers at $remotePath."
-            Fox.successful(layersWithVoxelSizes)
-          case f: Failure =>
-            reportMutable += s"Error when reading $remotePath as ${currentExplorer.name}: ${Fox.failureChainAsString(f)}"
-            exploreRemoteLayersForRemotePath(remotePath, credentialId, reportMutable, remainingExplorers)
-          case Empty =>
-            reportMutable += s"Error when reading $remotePath as ${currentExplorer.name}: Empty"
-            exploreRemoteLayersForRemotePath(remotePath, credentialId, reportMutable, remainingExplorers)
-        }
-    }
-
-}
diff --git a/app/models/dataset/explore/WKExploreRemoteLayerService.scala b/app/models/dataset/explore/WKExploreRemoteLayerService.scala
new file mode 100644
index 00000000000..c70b12b79ad
--- /dev/null
+++ b/app/models/dataset/explore/WKExploreRemoteLayerService.scala
@@ -0,0 +1,120 @@
+package models.dataset.explore
+
+import collections.SequenceUtils
+import com.scalableminds.util.accesscontext.{DBAccessContext, GlobalAccessContext}
+import com.scalableminds.util.geometry.Vec3Double
+import com.scalableminds.util.tools.{Fox, FoxImplicits}
+import com.scalableminds.webknossos.datastore.explore.{
+  ExploreLayerUtils,
+  ExploreRemoteDatasetResponse,
+  ExploreRemoteLayerParameters
+}
+import com.scalableminds.webknossos.datastore.models.datasource._
+import com.scalableminds.webknossos.datastore.rpc.RPC
+import com.typesafe.scalalogging.LazyLogging
+import models.dataset.{DataStore, DataStoreDAO, DatasetService, WKRemoteDataStoreClient}
+import models.dataset.credential.CredentialService
+import models.organization.OrganizationDAO
+import models.user.User
+import net.liftweb.common.Box.tryo
+import play.api.libs.json.{Json, OFormat}
+import security.WkSilhouetteEnvironment
+import utils.ObjectId
+
+import java.net.URI
+import javax.inject.Inject
+import scala.concurrent.ExecutionContext
+
+case class WKExploreRemoteLayerParameters(remoteUri: String,
+                                          credentialIdentifier: Option[String],
+                                          credentialSecret: Option[String],
+                                          preferredVoxelSize: Option[Vec3Double],
+                                          dataStoreName: Option[String])
+
+object WKExploreRemoteLayerParameters {
+  implicit val jsonFormat: OFormat[WKExploreRemoteLayerParameters] = Json.format[WKExploreRemoteLayerParameters]
+}
+
+case class ExploreAndAddRemoteDatasetParameters(remoteUri: String,
+                                                datasetName: String,
+                                                folderPath: Option[String],
+                                                dataStoreName: Option[String])
+
+object ExploreAndAddRemoteDatasetParameters {
+  implicit val jsonFormat: OFormat[ExploreAndAddRemoteDatasetParameters] =
+    Json.format[ExploreAndAddRemoteDatasetParameters]
+}
+
+class WKExploreRemoteLayerService @Inject()(credentialService: CredentialService,
+                                            organizationDAO: OrganizationDAO,
+                                            dataStoreDAO: DataStoreDAO,
+                                            datasetService: DatasetService,
+                                            wkSilhouetteEnvironment: WkSilhouetteEnvironment,
+                                            rpc: RPC)
+    extends FoxImplicits
+    with ExploreLayerUtils
+    with LazyLogging {
+
+  private lazy val bearerTokenService = wkSilhouetteEnvironment.combinedAuthenticatorService.tokenAuthenticatorService
+
+  def exploreRemoteDatasource(parameters: List[WKExploreRemoteLayerParameters], requestingUser: User)(
+      implicit ec: ExecutionContext): Fox[ExploreRemoteDatasetResponse] =
+    for {
+      credentialIds <- Fox.serialCombined(parameters)(
+        parameters =>
+          storeCredentials(parameters.remoteUri,
+                           parameters.credentialIdentifier,
+                           parameters.credentialSecret,
+                           requestingUser))
+      parametersWithCredentialId = parameters.zip(credentialIds).map {
+        case (originalParameters, credentialId) =>
+          ExploreRemoteLayerParameters(originalParameters.remoteUri,
+                                       credentialId.map(_.toString),
+                                       originalParameters.preferredVoxelSize)
+      }
+      datastore <- selectDataStore(parameters.map(_.dataStoreName))
+      client: WKRemoteDataStoreClient = new WKRemoteDataStoreClient(datastore, rpc)
+      organization <- organizationDAO.findOne(requestingUser._organization)(GlobalAccessContext)
+      userToken <- bearerTokenService.createAndInitDataStoreTokenForUser(requestingUser)
+      exploreResponse <- client.exploreRemoteDataset(parametersWithCredentialId, organization.name, userToken)
+    } yield exploreResponse
+
+  private def selectDataStore(dataStoreNames: List[Option[String]])(implicit ec: ExecutionContext): Fox[DataStore] =
+    for {
+      dataStoreNameOpt <- SequenceUtils.findUniqueElement(dataStoreNames) ?~> "explore.dataStore.mustBeEqualForAll"
+      dataStore <- dataStoreNameOpt match {
+        case Some(dataStoreName) => dataStoreDAO.findOneByName(dataStoreName)(GlobalAccessContext)
+        case None                => dataStoreDAO.findOneWithUploadsAllowed(GlobalAccessContext)
+      }
+    } yield dataStore
+
+  private def storeCredentials(layerUri: String,
+                               credentialIdentifier: Option[String],
+                               credentialSecret: Option[String],
+                               requestingUser: User)(implicit ec: ExecutionContext): Fox[Option[ObjectId]] =
+    for {
+      uri <- tryo(new URI(removeHeaderFileNamesFromUriSuffix(layerUri))) ?~> s"Received invalid URI: $layerUri"
+      credentialOpt = credentialService.createCredentialOpt(uri,
+                                                            credentialIdentifier,
+                                                            credentialSecret,
+                                                            requestingUser._id,
+                                                            requestingUser._organization)
+      _ <- bool2Fox(uri.getScheme != null) ?~> s"Received invalid URI: $layerUri"
+      credentialId <- Fox.runOptional(credentialOpt)(c => credentialService.insertOne(c)) ?~> "dataVault.credential.insert.failed"
+    } yield credentialId
+
+  def addRemoteDatasource(dataSource: GenericDataSource[DataLayer],
+                          datasetName: String,
+                          user: User,
+                          folderId: Option[ObjectId])(implicit ctx: DBAccessContext): Fox[Unit] =
+    for {
+      organization <- organizationDAO.findOne(user._organization)
+      dataStore <- dataStoreDAO.findOneWithUploadsAllowed
+      _ <- datasetService.assertValidDatasetName(datasetName)
+      _ <- datasetService.assertNewDatasetName(datasetName, organization._id) ?~> "dataset.name.alreadyTaken"
+      client = new WKRemoteDataStoreClient(dataStore, rpc)
+      userToken <- bearerTokenService.createAndInitDataStoreTokenForUser(user)
+      _ <- client.addDataSource(organization.name, datasetName, dataSource, folderId, userToken)
+    } yield ()
+
+}
diff --git a/frontend/javascripts/admin/admin_rest_api.ts b/frontend/javascripts/admin/admin_rest_api.ts
index 6c86320b3eb..ddd4138d550 100644
--- a/frontend/javascripts/admin/admin_rest_api.ts
+++ b/frontend/javascripts/admin/admin_rest_api.ts
@@ -1644,6 +1644,7 @@ type ExplorationResult = {
 
 export async function exploreRemoteDataset(
   remoteUris: string[],
+  datastoreName: string,
   credentials?: { username: string; pass: string } | null,
   preferredVoxelSize?: Vector3,
 ): Promise<ExplorationResult> {
@@ -1652,6 +1653,7 @@ export async function exploreRemoteDataset(
       const extendedUri = {
         remoteUri: uri.trim(),
         preferredVoxelSize,
+        datastoreName,
       };
 
       if (credentials) {
diff --git a/frontend/javascripts/admin/dataset/dataset_add_remote_view.tsx b/frontend/javascripts/admin/dataset/dataset_add_remote_view.tsx
index 0c719027510..84a489365f4 100644
--- a/frontend/javascripts/admin/dataset/dataset_add_remote_view.tsx
+++ b/frontend/javascripts/admin/dataset/dataset_add_remote_view.tsx
@@ -19,7 +19,7 @@ import type { OxalisState } from "oxalis/store";
 import { exploreRemoteDataset, isDatasetNameValid, storeRemoteDataset } from "admin/admin_rest_api";
 import messages from "messages";
 import { jsonStringify } from "libs/utils";
-import { CardContainer } from "admin/dataset/dataset_components";
+import { CardContainer, DatastoreFormItem } from "admin/dataset/dataset_components";
 import Password from "antd/lib/input/Password";
 import { AsyncButton } from "components/async_clickables";
 import Toast from "libs/toast";
@@ -172,7 +172,10 @@ export function GoogleAuthFormItem({
 }
 
 function DatasetAddRemoteView(props: Props) {
-  const { activeUser, onAdded } = props;
+  const { activeUser, onAdded, datastores } = props;
+
+  const uploadableDatastores = datastores.filter((datastore) => datastore.allowsUpload);
+  const hasOnlyOneDatastoreOrNone = uploadableDatastores.length <= 1;
 
   const [showAddLayerModal, setShowAddLayerModal] = useState(false);
   const [dataSourceEditMode, setDataSourceEditMode] = useState<"simple" | "advanced">("simple");
@@ -201,8 +204,9 @@ function DatasetAddRemoteView(props: Props) {
     await form.validateFields();
     const datasourceConfigStr = form.getFieldValue("dataSourceJson");
 
-    const uploadableDatastores = props.datastores.filter((datastore) => datastore.allowsUpload);
-    const datastoreToUse = uploadableDatastores[0];
+    const datastoreToUse = uploadableDatastores.find(
+      (datastore) => form.getFieldValue("datastoreUrl") === datastore.url,
+    );
     if (!datastoreToUse) {
       Toast.error("Could not find datastore that allows uploading.");
       return;
@@ -240,6 +244,7 @@ function DatasetAddRemoteView(props: Props) {
     <div style={{ padding: 5 }}>
       <CardContainer title="Add Remote Zarr / Neuroglancer Precomputed / N5 Dataset">
         <Form form={form} layout="vertical">
+          <DatastoreFormItem datastores={uploadableDatastores} hidden={hasOnlyOneDatastoreOrNone} />
           <Modal
             title="Add Layer"
             width={800}
@@ -247,8 +252,9 @@ function DatasetAddRemoteView(props: Props) {
             footer={null}
             onCancel={() => setShowAddLayerModal(false)}
           >
-            <AddZarrLayer
+            <AddRemoteLayer
               form={form}
+              uploadableDatastores={uploadableDatastores}
               setDatasourceConfigStr={setDatasourceConfigStr}
               onSuccess={() => setShowAddLayerModal(false)}
               dataSourceEditMode={dataSourceEditMode}
@@ -256,8 +262,9 @@ function DatasetAddRemoteView(props: Props) {
           </Modal>
 
           {hideDatasetUI && (
-            <AddZarrLayer
+            <AddRemoteLayer
               form={form}
+              uploadableDatastores={uploadableDatastores}
               setDatasourceConfigStr={setDatasourceConfigStr}
               dataSourceEditMode={dataSourceEditMode}
             />
@@ -355,13 +362,15 @@ function DatasetAddRemoteView(props: Props) {
   );
 }
 
-function AddZarrLayer({
+function AddRemoteLayer({
   form,
+  uploadableDatastores,
   setDatasourceConfigStr,
   onSuccess,
   dataSourceEditMode,
 }: {
   form: FormInstance;
+  uploadableDatastores: APIDataStore[];
   setDatasourceConfigStr: (dataSourceJson: string) => void;
   onSuccess?: () => void;
   dataSourceEditMode: "simple" | "advanced";
@@ -404,6 +413,13 @@ function AddZarrLayer({
     // Sync simple with advanced and get newest datasourceJson
     syncDataSourceFields(form, dataSourceEditMode === "simple" ? "advanced" : "simple");
     const datasourceConfigStr = form.getFieldValue("dataSourceJson");
+    const datastoreToUse = uploadableDatastores.find(
+      (datastore) => form.getFieldValue("datastoreUrl") === datastore.url,
+    );
+    if (!datastoreToUse) {
+      Toast.error("Could not find datastore that allows uploading.");
+      return;
+    }
 
     const { dataSource: newDataSource, report } = await (async () => {
       // @ts-ignore
@@ -416,6 +432,7 @@ function AddZarrLayer({
           if (credentials) {
             return exploreRemoteDataset(
               [datasourceUrl],
+              datastoreToUse.name,
               {
                 username: "",
                 pass: JSON.stringify(credentials),
@@ -428,6 +445,7 @@ function AddZarrLayer({
         } else if (usernameOrAccessKey && passwordOrSecretKey) {
           return exploreRemoteDataset(
             [datasourceUrl],
+            datastoreToUse.name,
             {
               username: usernameOrAccessKey,
               pass: passwordOrSecretKey,
@@ -436,7 +454,7 @@ function AddZarrLayer({
           );
         }
       }
-      return exploreRemoteDataset([datasourceUrl], null, preferredVoxelSize);
+      return exploreRemoteDataset([datasourceUrl], datastoreToUse.name, null, preferredVoxelSize);
     })();
     setExploreLog(report);
     if (!newDataSource) {
diff --git a/frontend/javascripts/admin/dataset/dataset_upload_view.tsx b/frontend/javascripts/admin/dataset/dataset_upload_view.tsx
index d82206d9ff6..e2b2325ed6d 100644
--- a/frontend/javascripts/admin/dataset/dataset_upload_view.tsx
+++ b/frontend/javascripts/admin/dataset/dataset_upload_view.tsx
@@ -620,7 +620,6 @@ class DatasetUploadView extends React.Component<PropsWithFormAndRouter, State> {
   };
 
   render() {
-    const form = this.formRef.current;
     const { activeUser, withoutCard, datastores } = this.props;
     const isDatasetManagerOrAdmin = Utils.isUserAdminOrDatasetManager(this.props.activeUser);
 
@@ -712,8 +711,6 @@ class DatasetUploadView extends React.Component<PropsWithFormAndRouter, State> {
             </FormItemWithInfo>
 
             <DatastoreFormItem
-              // @ts-expect-error ts-migrate(2322) FIXME: Type '{ form: FormInstance<any> | null; datastores... Remove this comment to see the full error message
-              form={form}
               datastores={uploadableDatastores}
               hidden={hasOnlyOneDatastoreOrNone}
             />
diff --git a/util/src/main/scala/collections/SequenceUtils.scala b/util/src/main/scala/collections/SequenceUtils.scala
new file mode 100644
index 00000000000..9d839141c7d
--- /dev/null
+++ b/util/src/main/scala/collections/SequenceUtils.scala
@@ -0,0 +1,9 @@
+package collections
+
+object SequenceUtils {
+  def findUniqueElement[T](list: Seq[T]): Option[T] = {
+    val uniqueElements = list.distinct
+    if (uniqueElements.length == 1) uniqueElements.headOption
+    else None
+  }
+}
diff --git a/webknossos-datastore/app/com/scalableminds/webknossos/datastore/controllers/DataSourceController.scala b/webknossos-datastore/app/com/scalableminds/webknossos/datastore/controllers/DataSourceController.scala
index c21fa13c8f0..e9e1d59d28c 100644
--- a/webknossos-datastore/app/com/scalableminds/webknossos/datastore/controllers/DataSourceController.scala
+++ b/webknossos-datastore/app/com/scalableminds/webknossos/datastore/controllers/DataSourceController.scala
@@ -4,6 +4,11 @@ import com.google.inject.Inject
 import com.scalableminds.util.geometry.Vec3Int
 import com.scalableminds.util.tools.{Fox, FoxImplicits}
 import com.scalableminds.webknossos.datastore.ListOfLong.ListOfLong
+import com.scalableminds.webknossos.datastore.explore.{
+  ExploreRemoteDatasetRequest,
+  ExploreRemoteDatasetResponse,
+  ExploreRemoteLayerService
+}
 import com.scalableminds.webknossos.datastore.helpers.{
   GetMultipleSegmentIndexParameters,
   GetSegmentIndexParameters,
@@ -15,7 +20,7 @@ import com.scalableminds.webknossos.datastore.models.datasource.inbox.{
   InboxDataSourceLike,
   UnusableInboxDataSource
 }
-import com.scalableminds.webknossos.datastore.models.datasource.{DataLayer, DataSource, DataSourceId}
+import com.scalableminds.webknossos.datastore.models.datasource.{DataLayer, DataSource, DataSourceId, GenericDataSource}
 import com.scalableminds.webknossos.datastore.services._
 import com.scalableminds.webknossos.datastore.services.uploading.{
   CancelUploadInformation,
@@ -34,9 +39,10 @@ import play.api.mvc.{Action, AnyContent, MultipartFormData, PlayBodyParsers}
 
 import java.io.File
 import com.scalableminds.webknossos.datastore.storage.AgglomerateFileKey
-import net.liftweb.common.Full
+import net.liftweb.common.{Box, Empty, Failure, Full}
 import play.api.libs.Files
 
+import scala.collection.mutable.ListBuffer
 import scala.concurrent.{ExecutionContext, Future}
 import scala.concurrent.duration._
 
@@ -50,6 +56,7 @@ class DataSourceController @Inject()(
     segmentIndexFileService: SegmentIndexFileService,
     storageUsageService: DSUsedStorageService,
     datasetErrorLoggingService: DatasetErrorLoggingService,
+    exploreRemoteLayerService: ExploreRemoteLayerService,
     uploadService: UploadService,
     composeService: ComposeService,
     val dsRemoteWebknossosClient: DSRemoteWebknossosClient,
@@ -746,4 +753,31 @@ class DataSourceController @Inject()(
       }
     }
 
+  // Called directly by wk side
+  def exploreRemoteDataset(token: Option[String]): Action[ExploreRemoteDatasetRequest] =
+    Action.async(validateJson[ExploreRemoteDatasetRequest]) { implicit request =>
+      accessTokenService.validateAccess(UserAccessRequest.administrateDataSources(request.body.organizationName), token) {
+        val reportMutable = ListBuffer[String]()
+        for {
+          dataSourceBox: Box[GenericDataSource[DataLayer]] <- exploreRemoteLayerService
+            .exploreRemoteDatasource(request.body.layerParameters, reportMutable)
+            .futureBox
+          dataSourceOpt = dataSourceBox match {
+            case Full(dataSource) if dataSource.dataLayers.nonEmpty =>
+              reportMutable += s"Resulted in dataSource with ${dataSource.dataLayers.length} layers."
+              Some(dataSource)
+            case Full(_) =>
+              reportMutable += "Error when exploring as layer set: Resulted in zero layers."
+              None
+            case f: Failure =>
+              reportMutable += s"Error when exploring as layer set: ${Fox.failureChainAsString(f)}"
+              None
+            case Empty =>
+              reportMutable += "Error when exploring as layer set: Empty"
+              None
+          }
+        } yield Ok(Json.toJson(ExploreRemoteDatasetResponse(dataSourceOpt, reportMutable.mkString("\n"))))
+      }
+    }
+
 }
diff --git a/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ExploreLayerService.scala b/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ExploreLayerUtils.scala
similarity index 99%
rename from webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ExploreLayerService.scala
rename to webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ExploreLayerUtils.scala
index bbe4fac39d1..3d95ff4e891 100644
--- a/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ExploreLayerService.scala
+++ b/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ExploreLayerUtils.scala
@@ -15,7 +15,7 @@ import com.scalableminds.webknossos.datastore.models.datasource.{
 import scala.concurrent.ExecutionContext
 import scala.util.Try
 
-class ExploreLayerService extends FoxImplicits {
+trait ExploreLayerUtils extends FoxImplicits {
 
   def adaptLayersAndVoxelSize(layersWithVoxelSizes: List[(DataLayerWithMagLocators, Vec3Double)],
                               preferredVoxelSize: Option[Vec3Double])(
diff --git a/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ExploreLocalLayerService.scala b/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ExploreLocalLayerService.scala
index 9c98673f7e6..461360fe92d 100644
--- a/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ExploreLocalLayerService.scala
+++ b/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ExploreLocalLayerService.scala
@@ -21,8 +21,9 @@ import javax.inject.Inject
 import scala.concurrent.ExecutionContext
 import scala.jdk.CollectionConverters.IteratorHasAsScala
 
+// Calls explorers on local datasets that have already been uploaded to the binaryData dir
 class ExploreLocalLayerService @Inject()(dataVaultService: DataVaultService)
-    extends ExploreLayerService
+    extends ExploreLayerUtils
     with FoxImplicits {
 
   def exploreLocal(path: Path, dataSourceId: DataSourceId, layerDirectory: String = "")(
@@ -49,7 +50,7 @@ class ExploreLocalLayerService @Inject()(dataVaultService: DataVaultService)
           mag <- Fox
             .option2Fox(Vec3Int.fromMagLiteral(dir.getFileName.toString, allowScalar = true)) ?~> s"invalid mag: ${dir.getFileName}"
           vaultPath <- dataVaultService.getVaultPath(remoteSourceDescriptor) ?~> "dataVault.setup.failed"
-          layersWithVoxelSizes <- (new ZarrArrayExplorer(mag, ec)).explore(vaultPath, None)
+          layersWithVoxelSizes <- new ZarrArrayExplorer(mag).explore(vaultPath, None)
         } yield layersWithVoxelSizes))
       (layers, voxelSize) <- adaptLayersAndVoxelSize(layersWithVoxelSizes.flatten, None)
       relativeLayers = layers.map(selectLastTwoDirectories)
diff --git a/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ExploreRemoteLayerService.scala b/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ExploreRemoteLayerService.scala
new file mode 100644
index 00000000000..c97e1417763
--- /dev/null
+++ b/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ExploreRemoteLayerService.scala
@@ -0,0 +1,130 @@
+package com.scalableminds.webknossos.datastore.explore
+
+import com.scalableminds.util.geometry.{Vec3Double, Vec3Int}
+import com.scalableminds.util.tools.{Fox, FoxImplicits}
+import com.scalableminds.webknossos.datastore.DataStoreConfig
+import com.scalableminds.webknossos.datastore.datavault.VaultPath
+import com.scalableminds.webknossos.datastore.models.datasource.{
+  DataLayer,
+  DataLayerWithMagLocators,
+  DataSourceId,
+  GenericDataSource
+}
+import com.scalableminds.webknossos.datastore.services.DSRemoteWebknossosClient
+import com.scalableminds.webknossos.datastore.storage.{DataVaultCredential, DataVaultService, RemoteSourceDescriptor}
+import com.typesafe.scalalogging.LazyLogging
+import net.liftweb.common.Box.tryo
+import net.liftweb.common.{Empty, Failure, Full}
+import play.api.libs.json.{Json, OFormat}
+
+import java.net.URI
+import javax.inject.Inject
+import scala.collection.mutable.ListBuffer
+import scala.concurrent.ExecutionContext
+
+case class ExploreRemoteDatasetRequest(layerParameters: List[ExploreRemoteLayerParameters], organizationName: String)
+
+object ExploreRemoteDatasetRequest {
+  implicit val jsonFormat: OFormat[ExploreRemoteDatasetRequest] = Json.format[ExploreRemoteDatasetRequest]
+}
+
+case class ExploreRemoteDatasetResponse(dataSource: Option[GenericDataSource[DataLayer]], report: String)
+
+object ExploreRemoteDatasetResponse {
+  implicit val jsonFormat: OFormat[ExploreRemoteDatasetResponse] = Json.format[ExploreRemoteDatasetResponse]
+}
+
+case class ExploreRemoteLayerParameters(remoteUri: String,
+                                        credentialId: Option[String],
+                                        preferredVoxelSize: Option[Vec3Double])
+
+object ExploreRemoteLayerParameters {
+  implicit val jsonFormat: OFormat[ExploreRemoteLayerParameters] = Json.format[ExploreRemoteLayerParameters]
+}
+
+// Calls explorers on dataset uris compatible with DataVaults (can also be file:/// for local)
+class ExploreRemoteLayerService @Inject()(dataVaultService: DataVaultService,
+                                          remoteWebknossosClient: DSRemoteWebknossosClient,
+                                          dataStoreConfig: DataStoreConfig)
+    extends ExploreLayerUtils
+    with FoxImplicits
+    with LazyLogging {
+
+  def exploreRemoteDatasource(parameters: List[ExploreRemoteLayerParameters], reportMutable: ListBuffer[String])(
+      implicit ec: ExecutionContext): Fox[GenericDataSource[DataLayer]] =
+    for {
+      exploredLayersNested <- Fox.serialCombined(parameters)(
+        parameters =>
+          exploreRemoteLayersForOneUri(
+            parameters.remoteUri,
+            parameters.credentialId,
+            reportMutable
+        ))
+      layersWithVoxelSizes = exploredLayersNested.flatten
+      preferredVoxelSize = parameters.flatMap(_.preferredVoxelSize).headOption
+      _ <- bool2Fox(layersWithVoxelSizes.nonEmpty) ?~> "Detected zero layers"
+      (layers, voxelSize) <- adaptLayersAndVoxelSize(layersWithVoxelSizes, preferredVoxelSize)
+      dataSource = GenericDataSource[DataLayer](
+        DataSourceId("", ""), // Frontend will prompt user for a good name
+        layers,
+        voxelSize
+      )
+    } yield dataSource
+
+  private def exploreRemoteLayersForOneUri(layerUri: String,
+                                           credentialId: Option[String],
+                                           reportMutable: ListBuffer[String])(
+      implicit ec: ExecutionContext): Fox[List[(DataLayerWithMagLocators, Vec3Double)]] =
+    for {
+      uri <- tryo(new URI(removeHeaderFileNamesFromUriSuffix(layerUri))) ?~> s"Received invalid URI: $layerUri"
+      _ <- bool2Fox(uri.getScheme != null) ?~> s"Received invalid URI: $layerUri"
+      _ <- assertLocalPathInWhitelist(uri)
+      credentialOpt: Option[DataVaultCredential] <- Fox.runOptional(credentialId)(remoteWebknossosClient.getCredential)
+      remoteSource = RemoteSourceDescriptor(uri, credentialOpt)
+      remotePath <- dataVaultService.getVaultPath(remoteSource) ?~> "dataVault.setup.failed"
+      layersWithVoxelSizes <- exploreRemoteLayersForRemotePath(
+        remotePath,
+        credentialId,
+        reportMutable,
+        List(
+          new ZarrArrayExplorer(Vec3Int.ones),
+          new NgffExplorer,
+          new WebknossosZarrExplorer,
+          new N5ArrayExplorer,
+          new N5MultiscalesExplorer,
+          new PrecomputedExplorer,
+          new Zarr3ArrayExplorer,
+          new NeuroglancerUriExplorer(dataVaultService)
+        )
+      )
+    } yield layersWithVoxelSizes
+
+  private def assertLocalPathInWhitelist(uri: URI)(implicit ec: ExecutionContext): Fox[Unit] =
+    if (uri.getScheme == DataVaultService.schemeFile) {
+      bool2Fox(dataStoreConfig.Datastore.localFolderWhitelist.exists(whitelistEntry =>
+        uri.getPath.startsWith(whitelistEntry))) ?~> s"Absolute path ${uri.getPath} in local file system is not in path whitelist. Consider adding it to datastore.localFolderWhitelist"
+    } else Fox.successful(())
+
+  private def exploreRemoteLayersForRemotePath(remotePath: VaultPath,
+                                               credentialId: Option[String],
+                                               reportMutable: ListBuffer[String],
+                                               explorers: List[RemoteLayerExplorer])(
+      implicit ec: ExecutionContext): Fox[List[(DataLayerWithMagLocators, Vec3Double)]] =
+    explorers match {
+      case Nil => Fox.empty
+      case currentExplorer :: remainingExplorers =>
+        reportMutable += s"\nTrying to explore $remotePath as ${currentExplorer.name}..."
+        currentExplorer.explore(remotePath, credentialId).futureBox.flatMap {
+          case Full(layersWithVoxelSizes) =>
+            reportMutable += s"Found ${layersWithVoxelSizes.length} ${currentExplorer.name} layers at $remotePath."
+            Fox.successful(layersWithVoxelSizes)
+          case f: Failure =>
+            reportMutable += s"Error when reading $remotePath as ${currentExplorer.name}: ${Fox.failureChainAsString(f)}"
+            exploreRemoteLayersForRemotePath(remotePath, credentialId, reportMutable, remainingExplorers)
+          case Empty =>
+            reportMutable += s"Error when reading $remotePath as ${currentExplorer.name}: Empty"
+            exploreRemoteLayersForRemotePath(remotePath, credentialId, reportMutable, remainingExplorers)
+        }
+    }
+
+}
diff --git a/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/NeuroglancerUriExplorer.scala b/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/NeuroglancerUriExplorer.scala
index db1c7da4bf2..46d8e4c5d5d 100644
--- a/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/NeuroglancerUriExplorer.scala
+++ b/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/NeuroglancerUriExplorer.scala
@@ -10,13 +10,11 @@ import net.liftweb.common.Box.tryo
 import play.api.libs.json._
 
 import java.net.URI
-import javax.inject.Inject
 import scala.concurrent.ExecutionContext
 
-class NeuroglancerUriExplorer @Inject()(dataVaultService: DataVaultService,
-                                        exploreLayerService: ExploreLayerService,
-                                        implicit val ec: ExecutionContext)
-    extends RemoteLayerExplorer {
+class NeuroglancerUriExplorer(dataVaultService: DataVaultService)(implicit val ec: ExecutionContext)
+    extends RemoteLayerExplorer
+    with ExploreLayerUtils {
   override def name: String = "Neuroglancer URI Explorer"
 
   override def explore(remotePath: VaultPath,
@@ -30,7 +28,7 @@ class NeuroglancerUriExplorer @Inject()(dataVaultService: DataVaultService,
       exploredLayers = layerSpecs.value.map(exploreNeuroglancerLayer).toList
       layerLists <- Fox.combined(exploredLayers)
       layers = layerLists.flatten
-      renamedLayers = exploreLayerService.makeLayerNamesUnique(layers.map(_._1))
+      renamedLayers = makeLayerNamesUnique(layers.map(_._1))
     } yield renamedLayers.zip(layers.map(_._2))
 
   private def exploreNeuroglancerLayer(layerSpec: JsValue): Fox[List[(DataLayerWithMagLocators, Vec3Double)]] =
@@ -59,7 +57,7 @@ class NeuroglancerUriExplorer @Inject()(dataVaultService: DataVaultService,
       case "zarr" | "zarr2" =>
         Fox.firstSuccess(
           Seq(new NgffExplorer().explore(remotePath, None),
-              new ZarrArrayExplorer(Vec3Int.ones, ec).explore(remotePath, None)))
+              new ZarrArrayExplorer(Vec3Int.ones).explore(remotePath, None)))
       case "zarr3" => new Zarr3ArrayExplorer().explore(remotePath, None)
       case _       => Fox.failure(f"Can not explore layer of $layerType type")
     }
diff --git a/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/RemoteLayerExplorer.scala b/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/RemoteLayerExplorer.scala
index cbd8ffd9e73..f98ba9e201b 100644
--- a/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/RemoteLayerExplorer.scala
+++ b/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/RemoteLayerExplorer.scala
@@ -1,5 +1,6 @@
 package com.scalableminds.webknossos.datastore.explore
 
+import collections.SequenceUtils
 import com.scalableminds.util.geometry.{BoundingBox, Vec3Double}
 import com.scalableminds.util.tools.TextUtils.normalizeStrong
 import com.scalableminds.util.tools.{Fox, FoxImplicits, JsonHelper}
@@ -42,10 +43,7 @@ trait RemoteLayerExplorer extends FoxImplicits {
 
   protected def elementClassFromMags(magsWithAttributes: List[MagWithAttributes]): Fox[ElementClass.Value] = {
     val elementClasses = magsWithAttributes.map(_.elementClass)
-    for {
-      head <- elementClasses.headOption.toFox
-      _ <- bool2Fox(elementClasses.forall(_ == head)) ?~> s"Element class must be the same for all mags of a layer. got $elementClasses"
-    } yield head
+    SequenceUtils.findUniqueElement(elementClasses) ?~> s"Element class must be the same for all mags of a layer. got $elementClasses"
   }
 
   protected def boundingBoxFromMags(magsWithAttributes: List[MagWithAttributes]): BoundingBox =
diff --git a/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ZarrArrayExplorer.scala b/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ZarrArrayExplorer.scala
index 73cdc2ba930..9fb7a8cd7dd 100644
--- a/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ZarrArrayExplorer.scala
+++ b/webknossos-datastore/app/com/scalableminds/webknossos/datastore/explore/ZarrArrayExplorer.scala
@@ -11,7 +11,7 @@ import com.scalableminds.webknossos.datastore.models.datasource.Category
 
 import scala.concurrent.ExecutionContext
 
-class ZarrArrayExplorer(mag: Vec3Int = Vec3Int.ones, implicit val ec: ExecutionContext) extends RemoteLayerExplorer {
+class ZarrArrayExplorer(mag: Vec3Int = Vec3Int.ones)(implicit val ec: ExecutionContext) extends RemoteLayerExplorer {
 
   override def name: String = "Zarr Array"
 
diff --git a/webknossos-datastore/conf/com.scalableminds.webknossos.datastore.routes b/webknossos-datastore/conf/com.scalableminds.webknossos.datastore.routes
index cb95b225cdc..35f363740b0 100644
--- a/webknossos-datastore/conf/com.scalableminds.webknossos.datastore.routes
+++ b/webknossos-datastore/conf/com.scalableminds.webknossos.datastore.routes
@@ -91,6 +91,7 @@ PUT           /datasets/:organizationName/:datasetName
 GET           /datasets/:organizationName/:datasetName                                                                                        @com.scalableminds.webknossos.datastore.controllers.DataSourceController.suggestDatasourceJson(token: Option[String], organizationName: String, datasetName: String)
 DELETE        /datasets/:organizationName/:datasetName/deleteOnDisk                                                                           @com.scalableminds.webknossos.datastore.controllers.DataSourceController.deleteOnDisk(token: Option[String], organizationName: String, datasetName: String)
 POST          /datasets/compose                                                                                                               @com.scalableminds.webknossos.datastore.controllers.DataSourceController.compose(token: Option[String])
+POST          /datasets/exploreRemote                                                                                                         @com.scalableminds.webknossos.datastore.controllers.DataSourceController.exploreRemoteDataset(token: Option[String])
 
 # Actions
 POST          /triggers/checkInboxBlocking                                                                                                    @com.scalableminds.webknossos.datastore.controllers.DataSourceController.triggerInboxCheckBlocking(token: Option[String])