diff --git a/CHANGES.rst b/CHANGES.rst
index c388c4f9c1..6196f6a6dd 100644
--- a/CHANGES.rst
+++ b/CHANGES.rst
@@ -12,6 +12,8 @@ Cubeviz
 Imviz
 ^^^^^
 
+- Aperture photometry (previously "Imviz Simple Aperture Photometry") now supports batch mode. [#2465]
+
 Mosviz
 ^^^^^^
 
diff --git a/docs/imviz/plugins.rst b/docs/imviz/plugins.rst
index c2da960ffa..c4fd9ed45b 100644
--- a/docs/imviz/plugins.rst
+++ b/docs/imviz/plugins.rst
@@ -161,8 +161,8 @@ This plugin only considers pixel locations, not sky coordinates.
 
 .. _aper-phot-simple:
 
-Simple Aperture Photometry
-==========================
+Aperture Photometry
+===================
 
 .. warning::
 
diff --git a/jdaviz/components/plugin_dataset_select.vue b/jdaviz/components/plugin_dataset_select.vue
index 2b2e2f5ce7..e13d4fe3aa 100644
--- a/jdaviz/components/plugin_dataset_select.vue
+++ b/jdaviz/components/plugin_dataset_select.vue
@@ -10,39 +10,68 @@
       :label="label ? label : 'Data'"
       :hint="hint ? hint : 'Select data.'"
       :rules="rules ? rules : []"
+      :multiple="multiselect"
+      :chips="multiselect"
       item-text="label"
       item-value="label"
       persistent-hint
     >
-    <template slot="selection" slot-scope="data">
-      <div class="single-line">
-        <span>
-          <j-layer-viewer-icon v-if="data.item.icon" span_style="margin-right: 4px" :icon="data.item.icon" :prevent_invert_if_dark="true"></j-layer-viewer-icon>
-          {{ data.item.label }}
-        </span>
-      </div>
-    </template>
-    <template slot="item" slot-scope="data">
-      <div class="single-line">
-        <span>
-          <j-layer-viewer-icon v-if="data.item.icon" span_style="margin-right: 4px" :icon="data.item.icon" :prevent_invert_if_dark="true"></j-layer-viewer-icon>
-          {{ data.item.label }}
-        </span>
-      </div>
-    </template>
+      <template slot="selection" slot-scope="data">
+        <div class="single-line" style="width: 100%">
+          <v-chip v-if="multiselect" style="width: calc(100% - 10px)">
+            <span>
+              <j-layer-viewer-icon v-if="data.item.icon" span_style="margin-right: 4px" :icon="data.item.icon" :prevent_invert_if_dark="true"></j-layer-viewer-icon>
+              {{ data.item.label }}
+            </span>
+          </v-chip>
+          <span v-else>
+            <j-layer-viewer-icon v-if="data.item.icon" span_style="margin-right: 4px" :icon="data.item.icon" :prevent_invert_if_dark="true"></j-layer-viewer-icon>
+            {{ data.item.label }}
+          </span>
+        </div>
+      </template>
+      <template v-slot:prepend-item v-if="multiselect">
+        <v-list-item
+        ripple
+        @mousedown.prevent
+        @click="() => {if (selected.length < items.length) { $emit('update:selected', items.map((item) => item.label))} else {$emit('update:selected', [])}}"
+        >
+        <v-list-item-action>
+          <v-icon>
+            {{ selected.length == items.length ? 'mdi-close-box' : selected.length ? 'mdi-minus-box' : 'mdi-checkbox-blank-outline' }}
+          </v-icon>
+        </v-list-item-action>
+        <v-list-item-content>
+          <v-list-item-title>
+            {{ selected.length < items.length ? "Select All" : "Clear All" }}
+          </v-list-item-title>
+        </v-list-item-content>
+        </v-list-item>
+        <v-divider class="mt-2"></v-divider>
+      </template>
+      <template slot="item" slot-scope="data">
+        <div class="single-line">
+          <span>
+            <j-layer-viewer-icon v-if="data.item.icon" span_style="margin-right: 4px" :icon="data.item.icon" :prevent_invert_if_dark="true"></j-layer-viewer-icon>
+            {{ data.item.label }}
+          </span>
+        </div>
+      </template>
    </v-select>
   </v-row>
  </div>
 </template>
 <script>
 module.exports = {
-  props: ['items', 'selected', 'label', 'hint', 'rules', 'show_if_single_entry']
+  props: ['items', 'selected', 'label', 'hint', 'rules', 'show_if_single_entry', 'multiselect']
 };
 </script>
 
-<style>
+<style scoped>
   .v-select__selections {
     flex-wrap: nowrap !important;
+    display: block !important;
+    margin-bottom: -32px;
   }
   .single-line {
       white-space: nowrap;
diff --git a/jdaviz/components/plugin_layer_select.vue b/jdaviz/components/plugin_layer_select.vue
index b72e730c4a..2b7a03c78b 100644
--- a/jdaviz/components/plugin_layer_select.vue
+++ b/jdaviz/components/plugin_layer_select.vue
@@ -18,7 +18,7 @@
     >
     <template slot="selection" slot-scope="data">
       <div class="single-line" style="width: 100%">
-        <v-chip v-if="multiselect" style="width: calc(100% - 20px)">
+        <v-chip v-if="multiselect" style="width: calc(100% - 10px)">
           <span>
             <j-layer-viewer-icon :icon="data.item.icon" :prevent_invert_if_dark="true"></j-layer-viewer-icon>
             {{ data.item.label }}
diff --git a/jdaviz/components/plugin_subset_select.vue b/jdaviz/components/plugin_subset_select.vue
index b5a6709b78..c4e93fc037 100644
--- a/jdaviz/components/plugin_subset_select.vue
+++ b/jdaviz/components/plugin_subset_select.vue
@@ -17,8 +17,8 @@
       persistent-hint
     >
       <template slot="selection" slot-scope="data">
-        <div class="single-line">
-          <v-chip v-if="multiselect" style="width: calc(100% - 20px)">
+        <div class="single-line" style="width: 100%">
+          <v-chip v-if="multiselect" style="width: calc(100% - 10px)">
             <span>
               <v-icon v-if="data.item.color" left :color="data.item.color">
                 {{ data.item.type=='spectral' ? 'mdi-chart-bell-curve' : 'mdi-chart-scatter-plot' }}
@@ -79,10 +79,12 @@ module.exports = {
 };
 </script>
 
-<style>
-.v-select__selections {
-  flex-wrap: nowrap !important;
-}
+<style scoped>
+  .v-select__selections {
+    flex-wrap: nowrap !important;
+    display: block !important;
+    margin-bottom: -32px;
+  }
   .single-line {
       white-space: nowrap;
       overflow: hidden;
diff --git a/jdaviz/configs/default/plugins/metadata_viewer/metadata_viewer.py b/jdaviz/configs/default/plugins/metadata_viewer/metadata_viewer.py
index 32452f5211..1d22239eae 100644
--- a/jdaviz/configs/default/plugins/metadata_viewer/metadata_viewer.py
+++ b/jdaviz/configs/default/plugins/metadata_viewer/metadata_viewer.py
@@ -54,6 +54,10 @@ def reset(self):
 
     @observe("dataset_selected")
     def show_metadata(self, event):
+        if not hasattr(self, 'dataset'):  # pragma: no cover
+            # plugin not fully initialized
+            return
+
         data = self.dataset.selected_dc_item
         if (data is None or not hasattr(data, 'meta') or not isinstance(data.meta, dict)
                 or len(data.meta) < 1):
diff --git a/jdaviz/configs/default/plugins/subset_plugin/subset_plugin.py b/jdaviz/configs/default/plugins/subset_plugin/subset_plugin.py
index d814eb56cc..af20ddf8e5 100644
--- a/jdaviz/configs/default/plugins/subset_plugin/subset_plugin.py
+++ b/jdaviz/configs/default/plugins/subset_plugin/subset_plugin.py
@@ -49,7 +49,7 @@ class SubsetPlugin(PluginTemplateMixin, DatasetSelectMixin):
 
     subplugins_opened = Any().tag(sync=True)
 
-    multiselect = Bool(False).tag(sync=True)
+    multiselect = Bool(False).tag(sync=True)  # multiselect only for subset
     is_centerable = Bool(False).tag(sync=True)
     can_simplify = Bool(False).tag(sync=True)
     can_freeze = Bool(False).tag(sync=True)
@@ -453,21 +453,30 @@ def _do_recentering(subset, subset_state):
             else:
                 self.set_center((x, y), subset_name=subset, update=True)
 
-        dict_subset_to_state = self.subset_select.selected_subset_state
         if not self.multiselect:
-            _do_recentering(self.subset_selected, dict_subset_to_state)
+            _do_recentering(self.subset_selected, self.subset_select.selected_subset_state)
         else:
-            for sub in self.subset_selected:
+            for sub, subset_state in zip(self.subset_selected,
+                                         self.subset_select.selected_subset_state):
                 if (sub != self.subset_select.default_text and
-                        not isinstance(dict_subset_to_state[sub], CompositeSubsetState)):
+                        not isinstance(subset_state, CompositeSubsetState)):
                     self.is_centerable = True
-                    _do_recentering(sub, dict_subset_to_state[sub])
+                    _do_recentering(sub, subset_state)
                 elif (sub != self.subset_select.default_text and
-                      isinstance(dict_subset_to_state[sub], CompositeSubsetState)):
+                      isinstance(subset_state, CompositeSubsetState)):
                     self.hub.broadcast(SnackbarMessage(f"Unable to recenter "
                                                        f"composite subset {sub}",
                                                        color='error', sender=self))
 
+    def _get_subset_state(self, subset_name=None):
+        if self.multiselect and not subset_name:
+            raise ValueError("Please include subset_name in when in multiselect mode")
+
+        if subset_name is not None:
+            return self.subset_select._get_subset_state(subset_name)
+        # guaranteed to only return a single entry because of check above
+        return self.subset_select.selected_subset_state
+
     def get_center(self, subset_name=None):
         """Return the center of the Subset.
         This may or may not be the centroid obtain from data.
@@ -489,14 +498,7 @@ def get_center(self, subset_name=None):
         if not self.is_centerable:  # no-op
             return
 
-        if self.multiselect and not subset_name:
-            raise ValueError("Please include subset_name in"
-                             " get_center call when in multiselect mode")
-        elif not self.multiselect:
-            subset_state = self.subset_select.selected_subset_state
-        elif self.multiselect and subset_name:
-            subset_state = self.subset_select.selected_subset_state[subset_name]
-
+        subset_state = self._get_subset_state(subset_name)
         return subset_state.center()
 
     def set_center(self, new_cen, subset_name=None, update=False):
@@ -525,13 +527,8 @@ def set_center(self, new_cen, subset_name=None, update=False):
         if not self.is_centerable:  # no-op
             return
 
-        if self.multiselect and not subset_name:
-            raise ValueError("Please include subset_name in"
-                             " set_center call when in multiselect mode")
-        elif not self.multiselect:
-            subset_state = self.subset_select.selected_subset_state
-        elif self.multiselect and subset_name:
-            subset_state = self.subset_select.selected_subset_state[subset_name]
+        subset_state = self._get_subset_state(subset_name)
+
         if isinstance(subset_state, RoiSubsetState):
             x, y = new_cen
             # x and y are arrays so this converts them back to floats
diff --git a/jdaviz/configs/imviz/helper.py b/jdaviz/configs/imviz/helper.py
index 9d9c53ccde..86b97676b8 100644
--- a/jdaviz/configs/imviz/helper.py
+++ b/jdaviz/configs/imviz/helper.py
@@ -267,7 +267,7 @@ def get_aperture_photometry_results(self):
             Photometry results if available or `None` otherwise.
 
         """
-        return self.plugins['Imviz Simple Aperture Photometry']._obj.export_table()
+        return self.plugins['Aperture Photometry']._obj.export_table()
 
     def get_catalog_source_results(self):
         """Return table of sources given by querying from a catalog, if any.
diff --git a/jdaviz/configs/imviz/plugins/aper_phot_simple/aper_phot_simple.py b/jdaviz/configs/imviz/plugins/aper_phot_simple/aper_phot_simple.py
index 7485f716ab..a516e10bb6 100644
--- a/jdaviz/configs/imviz/plugins/aper_phot_simple/aper_phot_simple.py
+++ b/jdaviz/configs/imviz/plugins/aper_phot_simple/aper_phot_simple.py
@@ -10,17 +10,20 @@
 from astropy.modeling.models import Gaussian1D
 from astropy.time import Time
 from glue.core.message import SubsetUpdateMessage
+from glue_jupyter.common.toolbar_vuetify import read_icon
 from ipywidgets import widget_serialization
 from packaging.version import Version
 from photutils.aperture import (ApertureStats, CircularAperture, EllipticalAperture,
                                 RectangularAperture)
 from traitlets import Any, Bool, Integer, List, Unicode, observe
 
+from jdaviz.core.custom_traitlets import FloatHandleEmpty
 from jdaviz.core.events import SnackbarMessage, LinkUpdatedMessage
 from jdaviz.core.region_translators import regions2aperture, _get_region_from_spatial_subset
 from jdaviz.core.registries import tray_registry
-from jdaviz.core.template_mixin import (PluginTemplateMixin, DatasetSelectMixin,
+from jdaviz.core.template_mixin import (PluginTemplateMixin, DatasetMultiSelectMixin,
                                         SubsetSelect, TableMixin, PlotMixin)
+from jdaviz.core.tools import ICON_DIR
 from jdaviz.utils import PRIHDR_KEY
 
 __all__ = ['SimpleAperturePhotometry']
@@ -28,18 +31,33 @@
 ASTROPY_LT_5_2 = Version(astropy.__version__) < Version('5.2')
 
 
-@tray_registry('imviz-aper-phot-simple', label="Imviz Simple Aperture Photometry")
-class SimpleAperturePhotometry(PluginTemplateMixin, DatasetSelectMixin, TableMixin, PlotMixin):
+@tray_registry('imviz-aper-phot-simple', label="Aperture Photometry")
+class SimpleAperturePhotometry(PluginTemplateMixin, DatasetMultiSelectMixin, TableMixin, PlotMixin):
+    """
+    The Aperture Photometry plugin performs aperture photometry for drawn regions.
+    See the :ref:`Aperture Photometry Plugin Documentation <aper-phot-simple>` for more details.
+
+    Only the following attributes and methods are available through the
+    :ref:`public plugin API <plugin-apis>`:
+
+    * :meth:`~jdaviz.core.template_mixin.PluginTemplateMixin.show`
+    * :meth:`~jdaviz.core.template_mixin.PluginTemplateMixin.open_in_tray`
+    """
     template_file = __file__, "aper_phot_simple.vue"
-    subset_items = List([]).tag(sync=True)
-    subset_selected = Unicode("").tag(sync=True)
-    subset_area = Integer().tag(sync=True)
-    bg_subset_items = List().tag(sync=True)
-    bg_subset_selected = Unicode("").tag(sync=True)
+    multiselect = Bool(False).tag(sync=True)
+
+    aperture_items = List([]).tag(sync=True)
+    aperture_selected = Any('').tag(sync=True)
+    aperture_area = Integer().tag(sync=True)
+    background_items = List().tag(sync=True)
+    background_selected = Unicode("").tag(sync=True)
     background_value = Any(0).tag(sync=True)
-    pixel_area = Any(0).tag(sync=True)
-    counts_factor = Any(0).tag(sync=True)
-    flux_scaling = Any(0).tag(sync=True)
+    pixel_area_multi_auto = Bool(True).tag(sync=True)
+    pixel_area = FloatHandleEmpty(0).tag(sync=True)
+    counts_factor = FloatHandleEmpty(0).tag(sync=True)
+    flux_scaling_multi_auto = Bool(True).tag(sync=True)
+    flux_scaling_warning = Unicode("").tag(sync=True)
+    flux_scaling = FloatHandleEmpty(0).tag(sync=True)
     result_available = Bool(False).tag(sync=True)
     result_failed_msg = Unicode("").tag(sync=True)
     results = List().tag(sync=True)
@@ -50,21 +68,27 @@ class SimpleAperturePhotometry(PluginTemplateMixin, DatasetSelectMixin, TableMix
     fit_radial_profile = Bool(False).tag(sync=True)
     fit_results = List().tag(sync=True)
 
+    icon_radialtocheck = Unicode(read_icon(os.path.join(ICON_DIR, 'radialtocheck.svg'), 'svg+xml')).tag(sync=True)  # noqa
+    icon_checktoradial = Unicode(read_icon(os.path.join(ICON_DIR, 'checktoradial.svg'), 'svg+xml')).tag(sync=True)  # noqa
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
-        self.subset = SubsetSelect(self,
-                                   'subset_items',
-                                   'subset_selected',
-                                   default_text=None,
-                                   filters=['is_spatial', 'is_not_composite', 'is_not_annulus'])
-
-        self.bg_subset = SubsetSelect(self,
-                                      'bg_subset_items',
-                                      'bg_subset_selected',
-                                      default_text='Manual',
-                                      manual_options=['Manual'],
-                                      filters=['is_spatial', 'is_not_composite'])
+        self.aperture = SubsetSelect(self,
+                                     'aperture_items',
+                                     'aperture_selected',
+                                     multiselect='multiselect',
+                                     dataset='dataset',
+                                     default_text=None,
+                                     filters=['is_spatial', 'is_not_composite', 'is_not_annulus'])
+
+        self.background = SubsetSelect(self,
+                                       'background_items',
+                                       'background_selected',
+                                       dataset='dataset',
+                                       default_text='Manual',
+                                       manual_options=['Manual'],
+                                       filters=['is_spatial', 'is_not_composite'])
 
         headers = ['xcenter', 'ycenter', 'sky_center',
                    'sum', 'sum_aper_area',
@@ -77,8 +101,6 @@ def __init__(self, *args, **kwargs):
         self.table.headers_avail = headers
         self.table.headers_visible = headers
 
-        self._selected_data = None
-        self._selected_subset = None
         self.plot_types = ["Curve of Growth", "Radial Profile", "Radial Profile (Raw)"]
         self.current_plot_type = self.plot_types[0]
         self._fitted_model_name = 'phot_radial_profile'
@@ -90,106 +112,168 @@ def __init__(self, *args, **kwargs):
         self.session.hub.subscribe(self, SubsetUpdateMessage, handler=self._on_subset_update)
         self.session.hub.subscribe(self, LinkUpdatedMessage, handler=self._on_link_update)
 
+# TODO: expose public API once finalized
+#    @property
+#    def user_api(self):
+#        return PluginUserApi(self, expose=('multiselect', 'dataset', 'aperture',
+#                                           'background', 'background_value',
+#                                           'pixel_area', 'counts_factor', 'flux_scaling',
+#                                           'calculate_photometry',
+#                                           'unpack_batch_options', 'calculate_batch_photometry'))
+
+    def _get_defaults_from_metadata(self, dataset=None):
+        defaults = {}
+        if dataset is None:
+            meta = self.dataset.selected_dc_item.meta.copy()
+        else:
+            meta = self.dataset._get_dc_item(dataset).meta.copy()
+
+        # Extract telescope specific unit conversion factors, if applicable.
+        if PRIHDR_KEY in meta:
+            meta.update(meta[PRIHDR_KEY])
+            del meta[PRIHDR_KEY]
+        if 'telescope' in meta:
+            telescope = meta['telescope']
+        else:
+            telescope = meta.get('TELESCOP', '')
+        if telescope == 'JWST':
+            if 'photometry' in meta and 'pixelarea_arcsecsq' in meta['photometry']:
+                defaults['pixel_area'] = meta['photometry']['pixelarea_arcsecsq']
+                if 'bunit_data' in meta and meta['bunit_data'] == u.Unit("MJy/sr"):
+                    # Hardcode the flux conversion factor from MJy to ABmag
+                    defaults['flux_scaling'] = 0.003631
+        elif telescope == 'HST':
+            # TODO: Add more HST support, as needed.
+            # HST pixel scales are from instrument handbooks.
+            # This is really not used because HST data does not have sr in unit.
+            # This is only for completeness.
+            # For counts conversion, PHOTFLAM is used to convert "counts" to flux manually,
+            # which is the opposite of JWST, so we just do not do it here.
+            instrument = meta.get('INSTRUME', '').lower()
+            detector = meta.get('DETECTOR', '').lower()
+            if instrument == 'acs':
+                if detector == 'wfc':
+                    defaults['pixel_area'] = 0.05 * 0.05
+                elif detector == 'hrc':  # pragma: no cover
+                    defaults['pixel_area'] = 0.028 * 0.025
+                elif detector == 'sbc':  # pragma: no cover
+                    defaults['pixel_area'] = 0.034 * 0.03
+            elif instrument == 'wfc3' and detector == 'uvis':  # pragma: no cover
+                defaults['pixel_area'] = 0.04 * 0.04
+
+        return defaults
+
+    @observe('flux_scaling_multi_auto')
+    def _multiselect_flux_scaling_warning(self, event={}):
+        if not self.flux_scaling_multi_auto:
+            self.flux_scaling_warning = ''
+            return
+        no_flux_scaling = [dataset for dataset in self.dataset.selected
+                           if 'flux_scaling' not in self._get_defaults_from_metadata(dataset)]
+        if len(no_flux_scaling):
+            self.flux_scaling_warning = ('Could not determine flux scaling for '
+                                         f'{", ".join(no_flux_scaling)}.  Those entries will '
+                                         'default to zero.  Turn off auto-mode to provide '
+                                         'flux-scaling manually.')
+        else:
+            self.flux_scaling_warning = ''
+
+    @observe('flux_scaling')
+    def _singleselect_flux_scaling_warning(self, event={}):
+        if not self.multiselect:
+            # disable warning once user changes value
+            self.flux_scaling_warning = ''
+
     @observe('dataset_selected')
     def _dataset_selected_changed(self, event={}):
+        if not hasattr(self, 'dataset'):
+            # plugin not fully initialized
+            return
+        if self.dataset.selected_dc_item is None:
+            return
+        if self.multiselect:
+            # defaults are applied within the loop if the auto-switches are enabled,
+            # but we still need to update the flux-scaling warning
+            self._multiselect_flux_scaling_warning()
+            return
+
         try:
-            self._selected_data = self.dataset.selected_dc_item
-            if self._selected_data is None:
-                return
+            defaults = self._get_defaults_from_metadata()
             self.counts_factor = 0
-            self.pixel_area = 0
-            self.flux_scaling = 0
-
-            # Extract telescope specific unit conversion factors, if applicable.
-            meta = self._selected_data.meta.copy()
-            if PRIHDR_KEY in meta:
-                meta.update(meta[PRIHDR_KEY])
-                del meta[PRIHDR_KEY]
-            if 'telescope' in meta:
-                telescope = meta['telescope']
+            self.pixel_area = defaults.get('pixel_area', 0)
+            self.flux_scaling = defaults.get('flux_scaling', 0)
+            if 'flux_scaling' in defaults:
+                self.flux_scaling_warning = ''
             else:
-                telescope = meta.get('TELESCOP', '')
-            if telescope == 'JWST':
-                if 'photometry' in meta and 'pixelarea_arcsecsq' in meta['photometry']:
-                    self.pixel_area = meta['photometry']['pixelarea_arcsecsq']
-                    if 'bunit_data' in meta and meta['bunit_data'] == u.Unit("MJy/sr"):
-                        # Hardcode the flux conversion factor from MJy to ABmag
-                        self.flux_scaling = 0.003631
-            elif telescope == 'HST':
-                # TODO: Add more HST support, as needed.
-                # HST pixel scales are from instrument handbooks.
-                # This is really not used because HST data does not have sr in unit.
-                # This is only for completeness.
-                # For counts conversion, PHOTFLAM is used to convert "counts" to flux manually,
-                # which is the opposite of JWST, so we just do not do it here.
-                instrument = meta.get('INSTRUME', '').lower()
-                detector = meta.get('DETECTOR', '').lower()
-                if instrument == 'acs':
-                    if detector == 'wfc':
-                        self.pixel_area = 0.05 * 0.05
-                    elif detector == 'hrc':  # pragma: no cover
-                        self.pixel_area = 0.028 * 0.025
-                    elif detector == 'sbc':  # pragma: no cover
-                        self.pixel_area = 0.034 * 0.03
-                elif instrument == 'wfc3' and detector == 'uvis':  # pragma: no cover
-                    self.pixel_area = 0.04 * 0.04
+                self.flux_scaling_warning = ('Could not determine flux scaling for '
+                                             f'{self.dataset.selected}, defaulting to zero.')
 
         except Exception as e:
-            self._selected_data = None
             self.hub.broadcast(SnackbarMessage(
                 f"Failed to extract {self.dataset_selected}: {repr(e)}",
                 color='error', sender=self))
 
-        # Update self._selected_subset with the new self._selected_data
-        # and auto-populate background, if applicable.
-        self._subset_selected_changed()
+        # auto-populate background, if applicable.
+        self._aperture_selected_changed()
 
     def _on_subset_update(self, msg):
-        if self.dataset_selected == '' or self.subset_selected == '':
+        if not self.dataset_selected or not self.aperture_selected:
+            return
+        if self.multiselect:
+            self._background_selected_changed()
             return
 
         sbst = msg.subset
-        if sbst.label == self.subset_selected and sbst.data.label == self.dataset_selected:
-            self._subset_selected_changed()
-        elif sbst.label == self.bg_subset_selected and sbst.data.label == self.dataset_selected:
-            self._bg_subset_selected_changed()
+        if sbst.label == self.aperture_selected and sbst.data.label == self.dataset_selected:
+            self._aperture_selected_changed()
+        elif sbst.label == self.background_selected and sbst.data.label == self.dataset_selected:
+            self._background_selected_changed()
 
     def _on_link_update(self, msg):
-        if self.dataset_selected == '' or self.subset_selected == '':
+        if not self.dataset_selected or not self.aperture_selected:
             return
 
         # Force background auto-calculation to update when linking has changed.
-        self._subset_selected_changed()
+        self._aperture_selected_changed()
 
-    @observe('subset_selected')
-    def _subset_selected_changed(self, event={}):
-        subset_selected = event.get('new', self.subset_selected)
-        if self._selected_data is None or subset_selected == '':
+    @observe('aperture_selected', 'multiselect')
+    def _aperture_selected_changed(self, event={}):
+        if not self.dataset_selected or not self.aperture_selected:
+            return
+        if self.multiselect is not isinstance(self.aperture_selected, list):
+            # then multiselect is in the process of changing but the traitlet for aperture_selected
+            # has not been updated internally yet
+            return
+        if self.multiselect:
+            self._background_selected_changed()
             return
 
+        # NOTE: aperture area is only used to determine if a warning should be shown in the UI
+        # and so does not need to be calculated within user API calls that don't act on traitlets
         try:
-            self._selected_subset = _get_region_from_spatial_subset(
-                self, self.subset.selected_subset_state)
-            self._selected_subset.meta['label'] = subset_selected
-
             # Sky subset does not have area. Not worth it to calculate just for a warning.
-            if hasattr(self._selected_subset, 'area'):
-                self.subset_area = int(np.ceil(self._selected_subset.area))
+            if hasattr(self.aperture.selected_spatial_region, 'area'):
+                self.aperture_area = int(np.ceil(self.aperture.selected_spatial_region.area))
             else:
-                self.subset_area = 0
-
+                self.aperture_area = 0
         except Exception as e:
-            self._selected_subset = None
             self.hub.broadcast(SnackbarMessage(
-                f"Failed to extract {subset_selected}: {repr(e)}", color='error', sender=self))
-
+                f"Failed to extract {self.aperture_selected}: {repr(e)}",
+                color='error', sender=self))
         else:
-            self._bg_subset_selected_changed()
+            self._background_selected_changed()
 
-    def _calc_bg_subset_median(self, reg):
+    def _calc_background_median(self, reg, data=None):
         # Basically same way image stats are calculated in vue_do_aper_phot()
         # except here we only care about one stat for the background.
-        data = self._selected_data
+        if data is None:
+            if self.multiselect:
+                if len(self.dataset.selected) == 1:
+                    data = self.dataset.selected_dc_item[0]
+                else:
+                    raise ValueError("cannot calculate background median in multiselect")
+            else:
+                data = self.dataset.selected_dc_item
         comp = data.get_component(data.main_components[0])
         if hasattr(reg, 'to_pixel'):
             reg = reg.to_pixel(data.coords)
@@ -199,126 +283,192 @@ def _calc_bg_subset_median(self, reg):
         # photutils/background/_utils.py --> nanmedian()
         return np.nanmedian(img_stat)  # Naturally in data unit
 
-    @observe('bg_subset_selected')
-    def _bg_subset_selected_changed(self, event={}):
-        bg_subset_selected = event.get('new', self.bg_subset_selected)
-        if bg_subset_selected == 'Manual':
+    @observe('background_selected')
+    def _background_selected_changed(self, event={}):
+        background_selected = event.get('new', self.background_selected)
+        if background_selected == 'Manual':
             # we'll later access the user's self.background_value directly
             return
 
+        if self.multiselect:
+            # background_value will be recomputed within batch mode anyways and will
+            # be replaced in the UI with a message
+            self.background_value = -1
+            return
+
         try:
-            reg = _get_region_from_spatial_subset(self, self.bg_subset.selected_subset_state)
-            self.background_value = self._calc_bg_subset_median(reg)
+            reg = _get_region_from_spatial_subset(self, self.background.selected_subset_state)
+            self.background_value = self._calc_background_median(reg)
         except Exception as e:
             self.background_value = 0
             self.hub.broadcast(SnackbarMessage(
-                f"Failed to extract {bg_subset_selected}: {repr(e)}", color='error', sender=self))
+                f"Failed to extract {background_selected}: {repr(e)}", color='error', sender=self))
 
-    def vue_do_aper_phot(self, *args, **kwargs):
-        if self._selected_data is None or self._selected_subset is None:
-            self.hub.broadcast(SnackbarMessage(
-                "No data for aperture photometry", color='error', sender=self))
-            return
+    def calculate_photometry(self, dataset=None, aperture=None, background=None,
+                             background_value=None, pixel_area=None, counts_factor=None,
+                             flux_scaling=None, add_to_table=True, update_plots=True):
+        """
+        Calculate aperture photometry given the values set in the plugin or any overrides provided
+        as arguments here (which will temporarily override plugin values for this calculation only).
 
-        data = self._selected_data
-        reg = self._selected_subset
+        Parameters
+        ----------
+        dataset : str, optional
+            Dataset to use for photometry.
+        aperture : str, optional
+            Subset to use as the aperture.
+        background : str, optional
+            Subset to use to calculate the background.
+        background_value : float, optional
+            Background to subtract, same unit as data.  Automatically computed if ``background``
+            is set to a subset.
+        pixel_area : float, optional
+            Pixel area in arcsec squared, only used if sr in data unit.
+        counts_factor : float, optional
+            Factor to convert data unit to counts, in unit of flux/counts.
+        flux_scaling : float, optional
+            Same unit as data, used in -2.5 * log(flux / flux_scaling).
+        add_to_table : bool, optional
+        update_plots : bool, optional
+
+        Returns
+        -------
+        table row, fit results
+        """
+        if self.multiselect and (dataset is None or aperture is None):  # pragma: no cover
+            raise ValueError("for batch mode, use calculate_batch_photometry")
+
+        if dataset is not None:
+            if dataset not in self.dataset.choices:  # pragma: no cover
+                raise ValueError(f"dataset must be one of {self.dataset.choices}")
+            data = self.dataset._get_dc_item(dataset)
+        else:
+            # we can use the pre-cached value
+            data = self.dataset.selected_dc_item
+
+        if aperture is not None and aperture not in self.aperture.choices:
+            raise ValueError(f"aperture must be one of {self.aperture.choices}")
+        if aperture is not None or dataset is not None:
+            reg = self.aperture._get_spatial_region(subset=aperture if aperture is not None else self.aperture.selected,  # noqa
+                                                    dataset=dataset if dataset is not None else self.dataset.selected)  # noqa
+        else:
+            # use the pre-cached value
+            reg = self.aperture.selected_spatial_region
 
         # Reset last fitted model
         fit_model = None
+        # TODO: remove _fitted_model_name cache?
         if self._fitted_model_name in self.app.fitted_models:
             del self.app.fitted_models[self._fitted_model_name]
 
+        comp = data.get_component(data.main_components[0])
+
+        if background is not None and background not in self.background.choices:  # pragma: no cover
+            raise ValueError(f"background must be one of {self.background.choices}")
+        if background_value is not None:
+            if ((background not in (None, 'Manual'))
+                    or (background is None and self.background_selected != 'Manual')):
+                raise ValueError("cannot provide background_value with background!='Manual'")
+        elif (background == 'Manual'
+                or (background is None and self.background.selected == 'Manual')):
+            background_value = self.background_value
+        elif background is None and dataset is None:
+            # use the previously-computed value in the plugin
+            background_value = self.background_value
+        else:
+            bg_reg = self.aperture._get_spatial_region(subset=background if background is not None else self.background.selected,  # noqa
+                                                       dataset=dataset if dataset is not None else self.dataset.selected)  # noqa
+            background_value = self._calc_background_median(bg_reg, data=data)
         try:
-            comp = data.get_component(data.main_components[0])
-            try:
-                bg = float(self.background_value)
-            except ValueError:  # Clearer error message
-                raise ValueError('Missing or invalid background value')
+            bg = float(background_value)
+        except ValueError:  # Clearer error message
+            raise ValueError('Missing or invalid background value')
 
-            if hasattr(reg, 'to_pixel'):
-                sky_center = reg.center
-                xcenter, ycenter = data.coords.world_to_pixel(sky_center)
+        if hasattr(reg, 'to_pixel'):
+            sky_center = reg.center
+            xcenter, ycenter = data.coords.world_to_pixel(sky_center)
+        else:
+            xcenter = reg.center.x
+            ycenter = reg.center.y
+            if data.coords is not None:
+                sky_center = data.coords.pixel_to_world(xcenter, ycenter)
             else:
-                xcenter = reg.center.x
-                ycenter = reg.center.y
-                if data.coords is not None:
-                    sky_center = data.coords.pixel_to_world(xcenter, ycenter)
-                else:
-                    sky_center = None
-
-            aperture = regions2aperture(reg)
-            include_pixarea_fac = False
-            include_counts_fac = False
-            include_flux_scale = False
-            comp_data = comp.data
-            if comp.units:
-                img_unit = u.Unit(comp.units)
-                bg = bg * img_unit
-                comp_data = comp_data << img_unit
-
-                if u.sr in img_unit.bases:  # TODO: Better way to detect surface brightness unit?
-                    try:
-                        pixarea = float(self.pixel_area)
-                    except ValueError:  # Clearer error message
-                        raise ValueError('Missing or invalid pixel area')
-                    if not np.allclose(pixarea, 0):
-                        include_pixarea_fac = True
-                if img_unit != u.count:
-                    try:
-                        ctfac = float(self.counts_factor)
-                    except ValueError:  # Clearer error message
-                        raise ValueError('Missing or invalid counts conversion factor')
-                    if not np.allclose(ctfac, 0):
-                        include_counts_fac = True
+                sky_center = None
+
+        aperture = regions2aperture(reg)
+        include_pixarea_fac = False
+        include_counts_fac = False
+        include_flux_scale = False
+        comp_data = comp.data
+        if comp.units:
+            img_unit = u.Unit(comp.units)
+            bg = bg * img_unit
+            comp_data = comp_data << img_unit
+
+            if u.sr in img_unit.bases:  # TODO: Better way to detect surface brightness unit?
                 try:
-                    flux_scale = float(self.flux_scaling)
+                    pixarea = float(pixel_area if pixel_area is not None else self.pixel_area)
                 except ValueError:  # Clearer error message
-                    raise ValueError('Missing or invalid flux scaling')
-                if not np.allclose(flux_scale, 0):
-                    include_flux_scale = True
-            phot_aperstats = ApertureStats(comp_data, aperture, wcs=data.coords, local_bkg=bg)
-            phot_table = phot_aperstats.to_table(columns=(
-                'id', 'sum', 'sum_aper_area',
-                'min', 'max', 'mean', 'median', 'mode', 'std', 'mad_std', 'var',
-                'biweight_location', 'biweight_midvariance', 'fwhm', 'semimajor_sigma',
-                'semiminor_sigma', 'orientation', 'eccentricity'))  # Some cols excluded, add back as needed.  # noqa
-            rawsum = phot_table['sum'][0]
-
-            if include_pixarea_fac:
-                pixarea = pixarea * (u.arcsec * u.arcsec / (u.pix * u.pix))
-                # NOTE: Sum already has npix value encoded, so we simply apply the npix unit here.
-                pixarea_fac = (u.pix * u.pix) * pixarea.to(u.sr / (u.pix * u.pix))
-                phot_table['sum'] = [rawsum * pixarea_fac]
-            else:
-                pixarea_fac = None
-
-            if include_counts_fac:
-                ctfac = ctfac * (rawsum.unit / u.count)
-                sum_ct = rawsum / ctfac
-                sum_ct_err = np.sqrt(sum_ct.value) * sum_ct.unit
-            else:
-                ctfac = None
-                sum_ct = None
-                sum_ct_err = None
+                    raise ValueError('Missing or invalid pixel area')
+                if not np.allclose(pixarea, 0):
+                    include_pixarea_fac = True
+            if img_unit != u.count:
+                try:
+                    ctfac = float(counts_factor if counts_factor is not None else self.counts_factor)  # noqa
+                except ValueError:  # Clearer error message
+                    raise ValueError('Missing or invalid counts conversion factor')
+                if not np.allclose(ctfac, 0):
+                    include_counts_fac = True
+            try:
+                flux_scale = float(flux_scaling if flux_scaling is not None else self.flux_scaling)
+            except ValueError:  # Clearer error message
+                raise ValueError('Missing or invalid flux scaling')
+            if not np.allclose(flux_scale, 0):
+                include_flux_scale = True
+        phot_aperstats = ApertureStats(comp_data, aperture, wcs=data.coords, local_bkg=bg)
+        phot_table = phot_aperstats.to_table(columns=(
+            'id', 'sum', 'sum_aper_area',
+            'min', 'max', 'mean', 'median', 'mode', 'std', 'mad_std', 'var',
+            'biweight_location', 'biweight_midvariance', 'fwhm', 'semimajor_sigma',
+            'semiminor_sigma', 'orientation', 'eccentricity'))  # Some cols excluded, add back as needed.  # noqa
+        rawsum = phot_table['sum'][0]
+
+        if include_pixarea_fac:
+            pixarea = pixarea * (u.arcsec * u.arcsec / (u.pix * u.pix))
+            # NOTE: Sum already has npix value encoded, so we simply apply the npix unit here.
+            pixarea_fac = (u.pix * u.pix) * pixarea.to(u.sr / (u.pix * u.pix))
+            phot_table['sum'] = [rawsum * pixarea_fac]
+        else:
+            pixarea_fac = None
 
-            if include_flux_scale:
-                flux_scale = flux_scale * phot_table['sum'][0].unit
-                sum_mag = -2.5 * np.log10(phot_table['sum'][0] / flux_scale) * u.mag
-            else:
-                flux_scale = None
-                sum_mag = None
-
-            # Extra info beyond photutils.
-            phot_table.add_columns(
-                [xcenter * u.pix, ycenter * u.pix, sky_center,
-                 bg, pixarea_fac, sum_ct, sum_ct_err, ctfac, sum_mag, flux_scale, data.label,
-                 reg.meta.get('label', ''), Time(datetime.now(tz=timezone.utc))],
-                names=['xcenter', 'ycenter', 'sky_center', 'background', 'pixarea_tot',
-                       'aperture_sum_counts', 'aperture_sum_counts_err', 'counts_fac',
-                       'aperture_sum_mag', 'flux_scaling',
-                       'data_label', 'subset_label', 'timestamp'],
-                indexes=[1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 18, 18, 18])
+        if include_counts_fac:
+            ctfac = ctfac * (rawsum.unit / u.count)
+            sum_ct = rawsum / ctfac
+            sum_ct_err = np.sqrt(sum_ct.value) * sum_ct.unit
+        else:
+            ctfac = None
+            sum_ct = None
+            sum_ct_err = None
 
+        if include_flux_scale:
+            flux_scale = flux_scale * phot_table['sum'][0].unit
+            sum_mag = -2.5 * np.log10(phot_table['sum'][0] / flux_scale) * u.mag
+        else:
+            flux_scale = None
+            sum_mag = None
+
+        # Extra info beyond photutils.
+        phot_table.add_columns(
+            [xcenter * u.pix, ycenter * u.pix, sky_center,
+             bg, pixarea_fac, sum_ct, sum_ct_err, ctfac, sum_mag, flux_scale, data.label,
+             reg.meta.get('label', ''), Time(datetime.now(tz=timezone.utc))],
+            names=['xcenter', 'ycenter', 'sky_center', 'background', 'pixarea_tot',
+                   'aperture_sum_counts', 'aperture_sum_counts_err', 'counts_fac',
+                   'aperture_sum_mag', 'flux_scaling',
+                   'data_label', 'subset_label', 'timestamp'],
+            indexes=[1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 18, 18, 18])
+
+        if add_to_table:
             try:
                 phot_table['id'][0] = self.table._qtable['id'].max() + 1
                 self.table.add_item(phot_table)
@@ -327,7 +477,8 @@ def vue_do_aper_phot(self, *args, **kwargs):
                 phot_table['id'][0] = 1
                 self.table.add_item(phot_table)
 
-            # Plots.
+        # Plots.
+        if update_plots:
             line = self.plot.marks['line']
             sc = self.plot.marks['scatter']
             fit_line = self.plot.marks['fit_line']
@@ -391,38 +542,31 @@ def vue_do_aper_phot(self, *args, **kwargs):
                 else:
                     self.plot.clear_marks('fit_line')
 
-        except Exception as e:  # pragma: no cover
-            self.plot.clear_all_marks()
-            msg = f"Aperture photometry failed: {repr(e)}"
-            self.hub.broadcast(SnackbarMessage(msg, color='error', sender=self))
-            self.result_failed_msg = msg
-        else:
-            self.result_failed_msg = ''
-
-            # Parse results for GUI.
-            tmp = []
-            for key in phot_table.colnames:
-                if key in ('id', 'data_label', 'subset_label', 'background', 'pixarea_tot',
-                           'counts_fac', 'aperture_sum_counts_err', 'flux_scaling', 'timestamp'):
-                    continue
-                x = phot_table[key][0]
-                if (isinstance(x, (int, float, u.Quantity)) and
-                        key not in ('xcenter', 'ycenter', 'sky_center', 'sum_aper_area',
-                                    'aperture_sum_counts', 'aperture_sum_mag')):
-                    tmp.append({'function': key, 'result': f'{x:.4e}'})
-                elif key == 'sky_center' and x is not None:
-                    tmp.append({'function': 'RA center', 'result': f'{x.ra.deg:.6f} deg'})
-                    tmp.append({'function': 'Dec center', 'result': f'{x.dec.deg:.6f} deg'})
-                elif key in ('xcenter', 'ycenter', 'sum_aper_area'):
-                    tmp.append({'function': key, 'result': f'{x:.1f}'})
-                elif key == 'aperture_sum_counts' and x is not None:
-                    tmp.append({'function': key, 'result':
-                                f'{x:.4e} ({phot_table["aperture_sum_counts_err"][0]:.4e})'})
-                elif key == 'aperture_sum_mag' and x is not None:
-                    tmp.append({'function': key, 'result': f'{x:.3f}'})
-                else:
-                    tmp.append({'function': key, 'result': str(x)})
+        # Parse results for GUI.
+        tmp = []
+        for key in phot_table.colnames:
+            if key in ('id', 'data_label', 'subset_label', 'background', 'pixarea_tot',
+                       'counts_fac', 'aperture_sum_counts_err', 'flux_scaling', 'timestamp'):
+                continue
+            x = phot_table[key][0]
+            if (isinstance(x, (int, float, u.Quantity)) and
+                    key not in ('xcenter', 'ycenter', 'sky_center', 'sum_aper_area',
+                                'aperture_sum_counts', 'aperture_sum_mag')):
+                tmp.append({'function': key, 'result': f'{x:.4e}'})
+            elif key == 'sky_center' and x is not None:
+                tmp.append({'function': 'RA center', 'result': f'{x.ra.deg:.6f} deg'})
+                tmp.append({'function': 'Dec center', 'result': f'{x.dec.deg:.6f} deg'})
+            elif key in ('xcenter', 'ycenter', 'sum_aper_area'):
+                tmp.append({'function': key, 'result': f'{x:.1f}'})
+            elif key == 'aperture_sum_counts' and x is not None:
+                tmp.append({'function': key, 'result':
+                            f'{x:.4e} ({phot_table["aperture_sum_counts_err"][0]:.4e})'})
+            elif key == 'aperture_sum_mag' and x is not None:
+                tmp.append({'function': key, 'result': f'{x:.3f}'})
+            else:
+                tmp.append({'function': key, 'result': str(x)})
 
+        if update_plots:
             # Also display fit results
             fit_tmp = []
             if fit_model is not None and isinstance(fit_model, Gaussian1D):
@@ -432,58 +576,89 @@ def vue_do_aper_phot(self, *args, **kwargs):
                         p_val = p_val.value
                     fit_tmp.append({'function': param, 'result': f'{p_val:.4e}'})
 
-            self.results = tmp
+        self.results = tmp
+        self.result_available = True
+
+        if update_plots:
             self.fit_results = fit_tmp
-            self.result_available = True
             self.plot_available = True
 
+        return phot_table, fit_model
+
+    def vue_do_aper_phot(self, *args, **kwargs):
+        if self.dataset_selected == '' or self.aperture_selected == '':
+            self.hub.broadcast(SnackbarMessage(
+                "No data for aperture photometry", color='error', sender=self))
+            return
+
+        try:
+            if self.multiselect:
+                # even though plots aren't show in the UI when in multiselect mode,
+                # we'll create the last entry so if multiselect is disabled, the last
+                # iteration will show and not result in confusing behavior
+                self.calculate_batch_photometry(add_to_table=True, update_plots=True)
+            else:
+                self.calculate_photometry(add_to_table=True, update_plots=True)
+        except Exception as e:  # pragma: no cover
+            self.plot.clear_all_marks()
+            msg = f"Aperture photometry failed: {repr(e)}"
+            self.hub.broadcast(SnackbarMessage(msg, color='error', sender=self))
+            self.result_failed_msg = msg
+        else:
+            self.result_failed_msg = ''
+
     def unpack_batch_options(self, **options):
         """
         Unpacks a dictionary of options for batch mode, including all combinations of any values
         passed as tuples or lists.  For example::
 
             unpack_batch_options(dataset=['image1', 'image2'],
-                                 subset=['Subset 1', 'Subset 2'],
-                                 bg_subset=['Subset 3'],
+                                 aperture=['Subset 1', 'Subset 2'],
+                                 background=['Subset 3'],
                                  flux_scaling=3
                                  )
 
         would result in::
 
-            [{'subset': 'Subset 1',
+            [{'aperture': 'Subset 1',
               'dataset': 'image1',
-              'bg_subset': 'Subset 3',
+              'background': 'Subset 3',
               'flux_scaling': 3},
-             {'subset': 'Subset 2',
+             {'aperture': 'Subset 2',
               'dataset': 'image1',
-              'bg_subset': 'Subset 3',
+              'background': 'Subset 3',
               'flux_scaling': 3},
-             {'subset': 'Subset 1',
+             {'aperture': 'Subset 1',
               'dataset': 'image2',
-              'bg_subset': 'Subset 3',
+              'background': 'Subset 3',
               'flux_scaling': 3},
-             {'subset': 'Subset 2',
+             {'aperture': 'Subset 2',
               'dataset': 'image2',
-              'bg_subset': 'Subset 3',
+              'background': 'Subset 3',
               'flux_scaling': 3}]
 
         Parameters
         ----------
-        options : dict
+        options : dict, optional
             Dictionary of values to override from the values set in the plugin/traitlets.  Each
             entry can either be a single value, or a list.  All combinations of those that contain
-            a list will be exposed
+            a list will be exposed.  If not provided and the plugin is in multiselect mode
+            (``multiselect = True``), then the current values set in the plugin will be used.
 
         Returns
         -------
         options : list
             List of all combinations of input parameters, which can then be used as input to
-            `batch_aper_phot`
+            `calculate_batch_photometry`.
         """
         if not isinstance(options, dict):
             raise TypeError("options must be a dictionary")
-        # TODO: when enabling user API for this plugin, this should check that all inputs are
-        # exposed to self.user_api (rather than the internal self)
+        if not options:
+            if not self.multiselect:  # pragma: no cover
+                raise ValueError("must either provide a dictionary or set plugin to multiselect mode")  # noqa
+            options = {'dataset': self.dataset.selected, 'aperture': self.aperture.selected}
+
+        # TODO: use self.user_api once API is made public
         user_api = self  # .user_api
         invalid_keys = [k for k in options.keys() if not hasattr(user_api, k)]
         if len(invalid_keys):
@@ -505,6 +680,8 @@ def _is_single(v):
                 mult_values[k] = this_value
 
         def _unpack_dict_list(mult_values, single_values):
+            if not len(mult_values):
+                return [single_values]
             options_list = []
             # loop over the first item in mult_values
             # any remaining mult values will require recursion
@@ -522,12 +699,11 @@ def _unpack_dict_list(mult_values, single_values):
 
         return _unpack_dict_list(mult_values, single_values)
 
-    def batch_aper_phot(self, options, full_exceptions=False):
+    def calculate_batch_photometry(self, options=[], add_to_table=True, update_plots=True,
+                                   full_exceptions=False):
         """
-        Run aperture photometry over a list of options.  Values will be looped in order and any
-        unprovided options will remain at there previous values (either from a previous entry
-        in the list or from the plugin).  The plugin itself will update and will remain at the
-        final state from the last entry in the list.
+        Run aperture photometry over a list of options.  Unprovided options will remain at their
+        values defined in the plugin.
 
         To provide a list of values per-input, use `unpack_batch_options` to and pass that as input
         here.
@@ -537,6 +713,10 @@ def batch_aper_phot(self, options, full_exceptions=False):
         options : list
             Each entry will result in one computation of aperture photometry and should be
             a dictionary of values to override from the values set in the plugin/traitlets.
+        add_to_table : bool
+            Whether to add results to the plugin table.
+        update_plots : bool
+            Whether to update the plugin plots for the last iteration.
         full_exceptions : bool, optional
             Whether to expose the full exception message for all failed iterations.
         """
@@ -545,37 +725,26 @@ def batch_aper_phot(self, options, full_exceptions=False):
             raise TypeError("options must be a list of dictionaries")
         if not np.all([isinstance(option, dict) for option in options]):
             raise TypeError("options must be a list of dictionaries")
-
-        # these traitlets are automatically set based on the values of other traitlets in the
-        # plugin, and so we should apply any user-overrides LAST
-        attrs_auto_update = ('counts_factor', 'pixel_area', 'flux_scaling',
-                             'subset_area', 'background_value')
+        if not len(options):
+            if not self.multiselect:  # pragma: no cover
+                raise ValueError("must either provide manual options or put the plugin in multiselect mode")  # noqa
+            # unpack the batch options as provided in the app
+            options = self.unpack_batch_options()
 
         failed_iters, exceptions = [], []
         for i, option in enumerate(options):
-            # NOTE: if we do not want the UI to update (and end up in the final state), then
-            # we would need to refactor the plugin so that all we can compute computed values
-            # from the selected dataset without necessarily observing and updating traitlets.
-            # We would still want to check any select component against the valid choices.
-            # We could then also skip creating/showing the plot and have a manual call to
-            # vue_do_aper_phot re-enable plotting
-
-            # order the dictionary so that items that might be automatically set based on other
-            # selections are applied LATER so that user-overrides can take place.
-            # NOTE: this could have non-obvious consequences if providing the override for
-            # one entry but not another.  Alternatively, we could reset all traitlets to the
-            # original state between each iteration of the for-loop
-            option_ordered = {k: v for k, v in option.items() if k not in attrs_auto_update}
-            option_ordered.update(**option)
-
+            # only update plots on the last iteration
+            this_update_plots = i == len(options) and update_plots
+            defaults = self._get_defaults_from_metadata(option.get('dataset',
+                                                                   self.dataset.selected))
+            if self.pixel_area_multi_auto:
+                option.setdefault('pixel_area', defaults.get('pixel_area', 0))
+            if self.flux_scaling_multi_auto:
+                option.setdefault('flux_scaling', defaults.get('flux_scaling', 0))
             try:
-                for attr, value in option.items():
-                    # TODO: when enabling user_api, skip this and call setattr directly
-                    # on self.user_api
-                    if hasattr(self, f'{attr}_selected'):
-                        attr = f'{attr}_selected'
-                    setattr(self, attr, value)
-                self.vue_do_aper_phot()
+                self.calculate_photometry(add_to_table=add_to_table,
+                                          update_plots=this_update_plots,
+                                          **option)
             except Exception as e:
                 failed_iters.append(i)
                 if full_exceptions:
diff --git a/jdaviz/configs/imviz/plugins/aper_phot_simple/aper_phot_simple.vue b/jdaviz/configs/imviz/plugins/aper_phot_simple/aper_phot_simple.vue
index de521f3de2..505cdcbfa1 100644
--- a/jdaviz/configs/imviz/plugins/aper_phot_simple/aper_phot_simple.vue
+++ b/jdaviz/configs/imviz/plugins/aper_phot_simple/aper_phot_simple.vue
@@ -1,54 +1,85 @@
 <template>
   <j-tray-plugin
-    description='Perform aperture photometry for a single region.'
+    description='Perform aperture photometry for drawn regions.'
     :link="docs_link || 'https://jdaviz.readthedocs.io/en/'+vdocs+'/'+config+'/plugins.html#simple-aperture-photometry'"
     :popout_button="popout_button">
 
+    <v-row>
+      <div style="width: calc(100% - 32px)">
+      </div>
+      <div style="width: 32px">
+        <j-tooltip tooltipcontent="Toggle batch mode">
+          <v-btn
+            icon
+            style="opacity: 0.7"
+            @click="() => {multiselect = !multiselect}"
+          >
+            <img :src="multiselect ? icon_checktoradial : icon_radialtocheck" width="24" class="invert-if-dark"/>
+          </v-btn>
+        </j-tooltip>
+      </div>
+    </v-row>
+
     <plugin-dataset-select
       :items="dataset_items"
       :selected.sync="dataset_selected"
+      :multiselect="multiselect"
       :show_if_single_entry="false"
       label="Data"
       hint="Select the data for photometry."
     />
 
-    <div v-if='dataset_selected'>
+    <div v-if='dataset_selected.length > 0'>
       <plugin-subset-select
-        :items="subset_items"
-        :selected.sync="subset_selected"
+        :items="aperture_items"
+        :selected.sync="aperture_selected"
+        :multiselect="multiselect"
         :show_if_single_entry="true"
         label="Aperture"
         hint="Select aperture region for photometry (cannot be an annulus or composite subset)."
       />
 
-      <div v-if="subset_selected">
+      <div v-if="aperture_selected.length > 0">
         <plugin-subset-select
-          :items="bg_subset_items"
-          :selected.sync="bg_subset_selected"
+          :items="background_items"
+          :selected.sync="background_selected"
           :show_if_single_entry="true"
           label="Background"
           hint="Select subset region for background calculation (cannot be a composite subset)."
         />
 
-        <v-row v-if="subset_selected === bg_subset_selected">
+        <v-row v-if="(multiselect && aperture_selected.includes(background_selected)) || aperture_selected === background_selected">
           <span class="v-messages v-messages__message text--secondary" style="color: red !important">
               Background and aperture cannot be set to the same subset
           </span>
         </v-row>
 
-        <v-row>
+        <v-row v-if="multiselect && background_selected !== 'Manual'">
+          <span class="v-messages v-messages__message text--secondary">
+            <b>Batch mode:</b> background value will be automatically computed for each selected data entry separately and exposed in the output table.
+          </span>
+        </v-row>
+        <v-row v-else>
           <v-text-field
             label="Background value"
             v-model.number="background_value"
             type="number"
             hint="Background to subtract, same unit as data"
-            :disabled="bg_subset_selected!='Manual'"
+            :disabled="background_selected!='Manual'"
             persistent-hint
           >
           </v-text-field>
         </v-row>
 
-        <v-row>
+        <v-row v-if="multiselect">
+          <v-switch
+            v-model="pixel_area_multi_auto"
+            label="Auto pixel area"
+            :hint="pixel_area_multi_auto ? 'Pixel area will be automatically computed for each selected data entry separately and exposed in the output table.' : 'Pixel area will be held fixed at the value below for each iteration.'"
+            persistent-hint
+          />
+        </v-row>
+        <v-row v-if="!multiselect || !pixel_area_multi_auto">
           <v-text-field
             label="Pixel area"
             v-model.number="pixel_area"
@@ -70,7 +101,15 @@
           </v-text-field>
         </v-row>
 
-        <v-row>
+        <v-row v-if="multiselect">
+          <v-switch
+            v-model="flux_scaling_multi_auto"
+            label="Auto flux scaling"
+            :hint="flux_scaling_multi_auto ? 'Flux scaling will be automatically computed for each selected data entry separately and exposed in the output table.' : 'Flux scaling will be held fixed at the value below for each iteration.'"
+            persistent-hint
+          />
+        </v-row>
+        <v-row v-if="!multiselect || !flux_scaling_multi_auto">
           <v-text-field
             label="Flux scaling"
             v-model.number="flux_scaling"
@@ -80,8 +119,13 @@
           >
           </v-text-field>
         </v-row>
+        <v-row v-if="flux_scaling_warning.length > 0">
+          <span class="v-messages v-messages__message text--secondary" style="color: red !important">
+            {{flux_scaling_warning}}
+          </span>
+        </v-row>
 
-        <v-row>
+        <v-row v-if="!multiselect">
           <v-select
             :menu-props="{ left: true }"
             attach
@@ -93,13 +137,13 @@
           ></v-select>
         </v-row>
 
-        <v-row v-if="current_plot_type==='Radial Profile (Raw)' && subset_area > 5000">
+        <v-row v-if="!multiselect && current_plot_type==='Radial Profile (Raw)' && aperture_area > 5000">
           <span class="v-messages v-messages__message text--secondary">
-              <b>WARNING</b>: Computing and displaying raw profile of an aperture containing ~{{subset_area}} pixels may be slow or unresponsive.
+              <b>WARNING</b>: Computing and displaying raw profile of an aperture containing ~{{aperture_area}} pixels may be slow or unresponsive.
           </span>
         </v-row>
 
-        <v-row v-if="current_plot_type.indexOf('Radial Profile') != -1">
+        <v-row v-if="!multiselect && current_plot_type.indexOf('Radial Profile') != -1">
 
           <v-switch
             label="Fit Gaussian"
@@ -110,7 +154,7 @@
         </v-row>
 
         <v-row justify="end">
-          <v-btn color="primary" text @click="do_aper_phot" :disabled="subset_selected === bg_subset_selected">Calculate</v-btn>
+          <v-btn color="primary" text @click="do_aper_phot" :disabled="aperture_selected === background_selected">Calculate</v-btn>
         </v-row>
       </div>
     </div>
@@ -121,11 +165,11 @@
       </span>
     </v-row>
 
-    <v-row v-if="plot_available">
+    <v-row v-if="!multiselect && plot_available">
       <jupyter-widget :widget="plot_widget"/> 
     </v-row>
 
-    <div v-if="plot_available && fit_radial_profile && current_plot_type != 'Curve of Growth'">
+    <div v-if="!multiselect && plot_available && fit_radial_profile && current_plot_type != 'Curve of Growth'">
       <j-plugin-section-header>Gaussian Fit Results</j-plugin-section-header>
       <v-row no-gutters>
         <v-col cols=6><U>Result</U></v-col>
@@ -142,7 +186,7 @@
       </v-row>
     </div>
 
-    <div v-if="result_available">
+    <div v-if="!multiselect && result_available">
       <j-plugin-section-header>Photometry Results</j-plugin-section-header>
 
       <v-row no-gutters>
@@ -158,7 +202,9 @@
         </v-col>
         <v-col cols=6>{{ item.result }}</v-col>
       </v-row>
+    </div>
 
+    <div v-if="result_available">
       <j-plugin-section-header>Results History</j-plugin-section-header>
       <jupyter-widget :widget="table_widget"></jupyter-widget> 
     </div>
diff --git a/jdaviz/configs/imviz/tests/test_parser.py b/jdaviz/configs/imviz/tests/test_parser.py
index 5b81a51d48..614ebfab77 100644
--- a/jdaviz/configs/imviz/tests/test_parser.py
+++ b/jdaviz/configs/imviz/tests/test_parser.py
@@ -265,9 +265,9 @@ def test_parse_jwst_nircam_level2(self, imviz_helper):
         # Test simple aperture photometry plugin.
         phot_plugin = imviz_helper.app.get_tray_item_from_name('imviz-aper-phot-simple')
         phot_plugin.data_selected = 'contents[DATA]'
-        phot_plugin.subset_selected = 'Subset 1'
+        phot_plugin.aperture_selected = 'Subset 1'
         assert_allclose(phot_plugin.background_value, 0)
-        phot_plugin.bg_subset_selected = 'Subset 2'
+        phot_plugin.background_selected = 'Subset 2'
         assert_allclose(phot_plugin.background_value, 0.1741226315498352)  # Subset 2 median
         # NOTE: jwst.datamodels.find_fits_keyword("PHOTMJSR")
         phot_plugin.counts_factor = (data.meta['photometry']['conversion_megajanskys'] /
@@ -395,7 +395,7 @@ def test_parse_hst_drz(self, imviz_helper):
                                                (1512, 2611))  # Galaxy
         phot_plugin = imviz_helper.app.get_tray_item_from_name('imviz-aper-phot-simple')
         phot_plugin.data_selected = 'contents[SCI,1]'
-        phot_plugin.subset_selected = 'Subset 1'
+        phot_plugin.aperture_selected = 'Subset 1'
         phot_plugin.background_value = 0.0014  # Manual entry: Median on whole array
         assert_allclose(phot_plugin.pixel_area, 0.0025)  # Not used but still auto-populated
         phot_plugin.vue_do_aper_phot()
diff --git a/jdaviz/configs/imviz/tests/test_simple_aper_phot.py b/jdaviz/configs/imviz/tests/test_simple_aper_phot.py
index 791f2f946c..024827f74d 100644
--- a/jdaviz/configs/imviz/tests/test_simple_aper_phot.py
+++ b/jdaviz/configs/imviz/tests/test_simple_aper_phot.py
@@ -31,31 +31,31 @@ def test_plugin_wcs_dithered(self):
             phot_plugin.dataset_selected = 'no_such_data'
         with pytest.raises(ValueError):
             # will raise an error and revert to first entry
-            phot_plugin.subset_selected = 'no_such_subset'
-        assert phot_plugin.subset_selected == ''
-        phot_plugin.subset_selected = phot_plugin.subset.labels[0]
+            phot_plugin.aperture_selected = 'no_such_subset'
+        assert phot_plugin.aperture_selected == ''
+        phot_plugin.aperture_selected = phot_plugin.aperture.labels[0]
         assert_allclose(phot_plugin.background_value, 0)
 
         phot_plugin.dataset_selected = 'has_wcs_1[SCI,1]'
-        phot_plugin.subset_selected = phot_plugin.subset.labels[0]
+        phot_plugin.aperture_selected = phot_plugin.aperture.labels[0]
         with pytest.raises(ValueError):
-            phot_plugin.bg_subset_selected = 'no_such_subset'
-        assert phot_plugin.bg_subset_selected == 'Manual'
+            phot_plugin.background_selected = 'no_such_subset'
+        assert phot_plugin.background_selected == 'Manual'
         assert_allclose(phot_plugin.background_value, 0)
 
         # Perform photometry on both images using same Subset.
         phot_plugin.dataset_selected = 'has_wcs_1[SCI,1]'
-        phot_plugin.subset_selected = 'Subset 1'
-        assert phot_plugin._selected_data is not None
+        phot_plugin.aperture_selected = 'Subset 1'
+        assert phot_plugin.dataset.selected_dc_item is not None
         phot_plugin.vue_do_aper_phot()
         tbl = self.imviz.get_aperture_photometry_results()
         assert len(tbl) == 1
 
         phot_plugin.dataset_selected = 'has_wcs_2[SCI,1]'
         phot_plugin.current_plot_type = 'Radial Profile (Raw)'
-        assert phot_plugin._selected_data is not None
-        assert phot_plugin._selected_subset is not None
-        assert phot_plugin.bg_subset.labels == ['Manual', 'Subset 1']
+        assert phot_plugin.dataset.selected_dc_item is not None
+        assert phot_plugin.aperture.selected_spatial_region is not None
+        assert phot_plugin.background.labels == ['Manual', 'Subset 1']
         assert_allclose(phot_plugin.background_value, 0)
         assert_allclose(phot_plugin.counts_factor, 0)
         assert_allclose(phot_plugin.pixel_area, 0)
@@ -114,7 +114,7 @@ def test_plugin_wcs_dithered(self):
         # Make sure it also works on an ellipse subset.
         self.imviz._apply_interactive_region('bqplot:ellipse', (0, 0), (9, 4))
         phot_plugin.dataset_selected = 'has_wcs_1[SCI,1]'
-        phot_plugin.subset_selected = 'Subset 2'
+        phot_plugin.aperture_selected = 'Subset 2'
         phot_plugin.current_plot_type = 'Radial Profile'
         phot_plugin.vue_do_aper_phot()
         tbl = self.imviz.get_aperture_photometry_results()
@@ -135,8 +135,8 @@ def test_plugin_wcs_dithered(self):
         # We also subtract off background from itself here.
         self.imviz._apply_interactive_region('bqplot:rectangle', (0, 0), (9, 9))
         phot_plugin.dataset_selected = 'has_wcs_1[SCI,1]'
-        phot_plugin.subset_selected = 'Subset 3'
-        phot_plugin.bg_subset_selected = 'Subset 3'
+        phot_plugin.aperture_selected = 'Subset 3'
+        phot_plugin.background_selected = 'Subset 3'
         assert_allclose(phot_plugin.background_value, 1)
         phot_plugin.vue_do_aper_phot()
         tbl = self.imviz.get_aperture_photometry_results()
@@ -154,9 +154,9 @@ def test_plugin_wcs_dithered(self):
         assert tbl[-1]['subset_label'] == 'Subset 3'
 
         # Make sure background auto-updates.
-        phot_plugin.bg_subset_selected = 'Manual'
+        phot_plugin.background_selected = 'Manual'
         assert_allclose(phot_plugin.background_value, 1)  # Keeps last value
-        phot_plugin.bg_subset_selected = 'Subset 1'
+        phot_plugin.background_selected = 'Subset 1'
         assert_allclose(phot_plugin.background_value, 1)
         self.imviz.load_data(np.ones((10, 10)) + 1, data_label='twos')
         phot_plugin.dataset_selected = 'twos'
@@ -168,52 +168,68 @@ def test_plugin_wcs_dithered(self):
         assert phot_plugin.plot.figure.title == 'Curve of growth from aperture center'
 
     def test_batch_unpack(self):
-        phot_plugin = self.imviz.app.get_tray_item_from_name('imviz-aper-phot-simple')
+        # TODO: remove ._obj when API is made public
+        phot_plugin = self.imviz.plugins['Aperture Photometry']._obj
 
         # NOTE: these input values are not currently validated, so it does not matter that the
         # datasets and subsets do not exist with these names (if that changes, this test will
         # need to be udpated accordingly)
         unpacked = phot_plugin.unpack_batch_options(dataset=['image1', 'image2'],
-                                                    subset=['Subset 1', 'Subset 2'],
-                                                    bg_subset=['Subset 3'],
+                                                    aperture=['Subset 1', 'Subset 2'],
+                                                    background=['Subset 3'],
                                                     flux_scaling=3)
-        assert unpacked == [{'subset': 'Subset 1',
+        assert unpacked == [{'aperture': 'Subset 1',
                              'dataset': 'image1',
-                             'bg_subset': 'Subset 3',
+                             'background': 'Subset 3',
                              'flux_scaling': 3},
-                            {'subset': 'Subset 2',
+                            {'aperture': 'Subset 2',
                              'dataset': 'image1',
-                             'bg_subset': 'Subset 3',
+                             'background': 'Subset 3',
                              'flux_scaling': 3},
-                            {'subset': 'Subset 1',
+                            {'aperture': 'Subset 1',
                              'dataset': 'image2',
-                             'bg_subset': 'Subset 3',
+                             'background': 'Subset 3',
                              'flux_scaling': 3},
-                            {'subset': 'Subset 2',
+                            {'aperture': 'Subset 2',
                              'dataset': 'image2',
-                             'bg_subset': 'Subset 3',
+                             'background': 'Subset 3',
                              'flux_scaling': 3}]
 
     def test_batch_phot(self):
         self.imviz.link_data(link_type='wcs')  # They are dithered by 1 pixel on X
         self.imviz._apply_interactive_region('bqplot:truecircle', (0, 0), (9, 9))  # Draw a circle
 
-        phot_plugin = self.imviz.app.get_tray_item_from_name('imviz-aper-phot-simple')
+        # TODO: remove ._obj when API is made public
+        phot_plugin = self.imviz.plugins['Aperture Photometry']._obj
         assert phot_plugin.dataset.choices == ['has_wcs_1[SCI,1]', 'has_wcs_2[SCI,1]']
-        assert phot_plugin.subset.choices == ['Subset 1']
+        assert phot_plugin.aperture.choices == ['Subset 1']
 
-        phot_plugin.batch_aper_phot([{'dataset': 'has_wcs_1[SCI,1]', 'subset': 'Subset 1'},
-                                     {'dataset': 'has_wcs_2[SCI,1]'}])
+        phot_plugin.aperture.selected = 'Subset 1'
+        phot_plugin.calculate_batch_photometry([{'dataset': 'has_wcs_1[SCI,1]', 'aperture': 'Subset 1'},  # noqa
+                                                {'dataset': 'has_wcs_2[SCI,1]'}])
 
         assert len(phot_plugin.table) == 2
 
         with pytest.raises(RuntimeError):
-            phot_plugin.batch_aper_phot([{'dataset': 'has_wcs_1[SCI,1]', 'subset': 'DNE'},
-                                         {'dataset': 'has_wcs_2[SCI,1]', 'subset': 'Subset 1'}])
+            phot_plugin.calculate_batch_photometry([{'dataset': 'has_wcs_1[SCI,1]', 'aperture': 'DNE'},  # noqa
+                                                    {'dataset': 'has_wcs_2[SCI,1]', 'aperture': 'Subset 1'}])  # noqa
 
         # second entry above should have been successful, resulting in one addition to the results
         assert len(phot_plugin.table) == 3
 
+        # now run through the UI directly
+        phot_plugin.multiselect = True
+        phot_plugin.dataset.select_all()
+        phot_plugin.aperture.select_none()
+        assert len(phot_plugin.unpack_batch_options()) == 0
+        phot_plugin.vue_do_aper_phot()
+
+        assert len(phot_plugin.table) == 3
+        phot_plugin.aperture.select_all()
+        assert len(phot_plugin.unpack_batch_options()) == 2
+        phot_plugin.vue_do_aper_phot()
+        assert len(phot_plugin.table) == 5
+
 
 class TestSimpleAperPhot_NoWCS(BaseImviz_WCS_NoWCS):
     def test_plugin_no_wcs(self):
@@ -222,7 +238,7 @@ def test_plugin_no_wcs(self):
         phot_plugin = self.imviz.app.get_tray_item_from_name('imviz-aper-phot-simple')
 
         phot_plugin.dataset_selected = 'has_wcs[SCI,1]'
-        phot_plugin.subset_selected = 'Subset 1'
+        phot_plugin.aperture_selected = 'Subset 1'
         phot_plugin.vue_do_aper_phot()
         tbl = self.imviz.get_aperture_photometry_results()
         assert len(tbl) == 1
@@ -265,7 +281,7 @@ def setup_class(self, imviz_helper):
 
         self.imviz = imviz_helper
         self.viewer = imviz_helper.default_viewer
-        self.phot_plugin = imviz_helper.plugins["Imviz Simple Aperture Photometry"]._obj
+        self.phot_plugin = imviz_helper.plugins["Aperture Photometry"]._obj
 
     @pytest.mark.parametrize(('data_label', 'local_bkg'), [
         ('gauss100_fits_wcs[PRIMARY,1]', 5.0),
@@ -280,8 +296,8 @@ def setup_class(self, imviz_helper):
     def test_aperphot(self, data_label, local_bkg, subset_label, expected_sum):
         """All data should give similar result for the same Subset."""
         self.phot_plugin.dataset_selected = data_label
-        self.phot_plugin.subset_selected = subset_label
-        self.phot_plugin.bg_subset_selected = 'Manual'
+        self.phot_plugin.aperture_selected = subset_label
+        self.phot_plugin.background_selected = 'Manual'
         self.phot_plugin.background_value = local_bkg
         self.phot_plugin.vue_do_aper_phot()
         tbl = self.imviz.get_aperture_photometry_results()
@@ -303,8 +319,8 @@ def test_sky_background(self, data_label, fac, bg_label, expected_bg):
         Down-sampled data has higher factor due to flux conservation.
         """
         self.phot_plugin.dataset_selected = data_label
-        self.phot_plugin.subset_selected = "Subset 1"  # Does not matter
-        self.phot_plugin.bg_subset_selected = bg_label
+        self.phot_plugin.aperture_selected = "Subset 1"  # Does not matter
+        self.phot_plugin.background_selected = bg_label
 
         # Imperfect down-sampling and abusing apertures, so 10% is good enough.
         assert_allclose(float(self.phot_plugin.background_value), expected_bg * fac, rtol=0.1)
@@ -331,8 +347,8 @@ def test_annulus_background(imviz_helper):
         PixCoord(x=150, y=25), inner_radius=7, outer_radius=17)
     imviz_helper.load_regions([annulus_1])
 
-    phot_plugin.subset_selected = 'Subset 1'
-    phot_plugin.bg_subset_selected = 'Subset 2'
+    phot_plugin.aperture_selected = 'Subset 1'
+    phot_plugin.background_selected = 'Subset 2'
 
     # Check annulus for ones
     assert_allclose(phot_plugin.background_value, 1)
@@ -351,25 +367,25 @@ def test_annulus_background(imviz_helper):
     imviz_helper.load_regions([annulus_2])
 
     # Subset 4 (annulus) should be available for the background but not the aperture
-    assert 'Subset 4' not in phot_plugin.subset.choices
-    assert 'Subset 4' in phot_plugin.bg_subset.choices
+    assert 'Subset 4' not in phot_plugin.aperture.choices
+    assert 'Subset 4' in phot_plugin.background.choices
 
-    phot_plugin.subset_selected = 'Subset 3'
-    phot_plugin.bg_subset_selected = 'Subset 4'
+    phot_plugin.aperture_selected = 'Subset 3'
+    phot_plugin.background_selected = 'Subset 4'
 
     # Check new annulus for four_gaussians
     assert_allclose(phot_plugin.background_value, 5.13918435824334)  # Changed
 
     # Switch to manual, should not change
-    phot_plugin.bg_subset_selected = 'Manual'
+    phot_plugin.background_selected = 'Manual'
     assert_allclose(phot_plugin.background_value, 5.13918435824334)
 
     # Switch to Subset, should change a lot because this is not background area
-    phot_plugin.bg_subset_selected = 'Subset 1'
+    phot_plugin.background_selected = 'Subset 1'
     assert_allclose(phot_plugin.background_value, 44.72559981461203)
 
     # Switch back to annulus, should be same as before in same mode
-    phot_plugin.bg_subset_selected = 'Subset 4'
+    phot_plugin.background_selected = 'Subset 4'
     assert_allclose(phot_plugin.background_value, 5.13918435824334)
 
     # Edit the annulus and make sure background updates
diff --git a/jdaviz/core/region_translators.py b/jdaviz/core/region_translators.py
index 2522b4ab17..a9e4a07b90 100644
--- a/jdaviz/core/region_translators.py
+++ b/jdaviz/core/region_translators.py
@@ -20,7 +20,7 @@
 __all__ = ['regions2roi', 'regions2aperture', 'aperture2regions']
 
 
-def _get_region_from_spatial_subset(plugin_obj, subset_state):
+def _get_region_from_spatial_subset(plugin_obj, subset_state, dataset=None):
     """Convert the given ``glue`` ROI subset state to ``regions`` shape.
 
     .. note:: This is for internal use only in Imviz plugins.
@@ -37,6 +37,9 @@ def _get_region_from_spatial_subset(plugin_obj, subset_state):
     subset_state : obj
         ROI subset state to translate.
 
+    dataset : string, optional
+        Name of the dataset.  If not provided, will look for ``plugin_obj.dataset_selected``.
+
     Returns
     -------
     reg : `regions.Region`
@@ -53,9 +56,12 @@ def _get_region_from_spatial_subset(plugin_obj, subset_state):
     # Subset is defined against its parent. This is not necessarily
     # the current viewer reference data, which can be changed.
 
+    if dataset is None:
+        dataset = plugin_obj.dataset_selected
+
     # See https://github.com/spacetelescope/jdaviz/issues/2230
     link_type = plugin_obj.app._jdaviz_helper.get_link_type(
-        subset_state.xatt.parent.label, plugin_obj.dataset_selected)
+        subset_state.xatt.parent.label, dataset)
 
     return roi_subset_state_to_region(subset_state, to_sky=(link_type == 'wcs'))
 
diff --git a/jdaviz/core/template_mixin.py b/jdaviz/core/template_mixin.py
index d17608caf9..6cfff06037 100644
--- a/jdaviz/core/template_mixin.py
+++ b/jdaviz/core/template_mixin.py
@@ -1,4 +1,5 @@
 from astropy.coordinates.sky_coordinate import SkyCoord
+from astropy.nddata import NDData
 from astropy.table import QTable
 from astropy.table.row import Row as QTableRow
 import astropy.units as u
@@ -31,6 +32,7 @@
 from jdaviz.core.events import (AddDataMessage, RemoveDataMessage,
                                 ViewerAddedMessage, ViewerRemovedMessage,
                                 ViewerRenamedMessage, SnackbarMessage)
+from jdaviz.core.region_translators import _get_region_from_spatial_subset
 from jdaviz.core.user_api import UserApiWrapper, PluginUserApi
 from jdaviz.utils import get_subset_type
 
@@ -46,7 +48,7 @@
            'ViewerSelect', 'ViewerSelectMixin',
            'LayerSelect', 'LayerSelectMixin',
            'NonFiniteUncertaintyMismatchMixin',
-           'DatasetSelect', 'DatasetSelectMixin',
+           'DatasetSelect', 'DatasetSelectMixin', 'DatasetMultiSelectMixin',
            'FileImportSelectPluginComponent', 'HasFileImportSelect',
            'Table', 'TableMixin',
            'Plot', 'PlotMixin',
@@ -617,7 +619,12 @@ def select_next(self):
             raise ValueError("currently in multiselect mode")
 
         cycle = self.choices
-        curr_ind = cycle.index(self.selected)
+        if not len(cycle):  # pragma: no cover
+            raise ValueError("no choices")
+        if self.selected == '':
+            curr_ind = -1
+        else:
+            curr_ind = cycle.index(self.selected)
         self.selected = cycle[(curr_ind + 1) % len(cycle)]
         return self.selected
 
@@ -744,7 +751,7 @@ def _is_valid_item(self, item, filter_callables={}):
     def _multiselect_changed(self, event):
         self._clear_cache()
         if self.is_multiselect:
-            self.selected = [self.selected]
+            self.selected = [self.selected] if self.selected != '' else []
         elif isinstance(self.selected, list) and len(self.selected):
             self.selected = self.selected[0]
         else:
@@ -1288,7 +1295,7 @@ def selected_obj(self):
                    if layer.layer.label in selected]
                   for viewer in viewers]
 
-        if not self.multiselect and len(layers) == 1:
+        if not self.is_multiselect and len(layers) == 1:
             return layers[0]
         else:
             return layers
@@ -1388,7 +1395,7 @@ class SubsetSelect(SelectPluginComponent):
 
     """
     def __init__(self, plugin, items, selected, multiselect=None, selected_has_subregions=None,
-                 viewers=None, default_text=None, manual_options=[], filters=[],
+                 dataset=None, viewers=None, default_text=None, manual_options=[], filters=[],
                  default_mode='default_text'):
         """
         Parameters
@@ -1399,8 +1406,13 @@ def __init__(self, plugin, items, selected, multiselect=None, selected_has_subre
             the name of the items traitlet defined in ``plugin``
         selected : str
             the name of the selected traitlet defined in ``plugin``
-        selected_has_subregions: str
+        multiselect : str
+            the name of the traitlet defining whether the dropdown should accept multiple selections
+        selected_has_subregions : str
             the name of the selected_has_subregions traitlet defined in ``plugin``, optional
+        dataset : str
+            the name of the dataset traitlet defined in ``plugin``, to be used for accessing how
+            the subset is applied to the data (masks, etc), optional
         viewers : list
             the reference names or ids of the viewer to extract the subregion.  If not provided o
             None, will loop through all references.
@@ -1420,11 +1432,20 @@ def __init__(self, plugin, items, selected, multiselect=None, selected_has_subre
                          multiselect=multiselect,
                          filters=filters,
                          selected_has_subregions=selected_has_subregions,
+                         dataset=dataset,
                          viewers=viewers,
                          default_text=default_text,
                          manual_options=manual_options,
                          default_mode=default_mode)
 
+        self._cached_properties += ["selected_subset_state",
+                                    "selected_spatial_region",
+                                    "selected_subset_mask"]
+        if dataset is not None:
+            # clear selected_subset_mask and selected_spatial_region on change to dataset
+            self.add_observe(self.dataset._plugin_traitlets['selected'],
+                             self._on_dataset_selected_changed)
+
         if selected_has_subregions is not None:
             self.selected_has_subregions = False
 
@@ -1441,6 +1462,9 @@ def _selected_changed(self, event):
         super()._selected_changed(event)
         self._update_has_subregions()
 
+    def _on_dataset_selected_changed(self, event):
+        self._clear_cache('selected_subset_mask', 'selected_spatial_region')
+
     def _subset_to_dict(self, subset):
         # find layer artist in default spectrum-viewer
         for viewer in self.viewers:
@@ -1499,7 +1523,8 @@ def _update_subset(self, subset, attribute=None):
             ((self.is_multiselect and subset.label in self.selected)
              or (subset.label == self.selected))):
             # updated the currently selected subset
-            self._clear_cache("selected_obj", "selected_item")
+            self._clear_cache("selected_obj", "selected_item", "selected_subset_state",
+                              "selected_subset_mask", "selected_subset", "selected_spatial_region")
             self._update_has_subregions()
 
     def _update_has_subregions(self):
@@ -1514,41 +1539,48 @@ def _update_has_subregions(self):
             else:
                 self.selected_has_subregions = len(self.selected_obj.subregions) > 1
 
-    @cached_property
-    def selected_obj(self):
+    def _get_selected_obj(self, selected):
         if (
-            self.selected in self.manual_options or
-            self.selected not in self.labels or
-            self.selected is None
+            selected in self.manual_options or
+            selected not in self.labels or
+            selected is None
         ):
             return None
-        return self.app.get_subsets(self.selected)
+        return self.app.get_subsets(selected)
 
-    @property
-    def selected_subset_state(self):
+    @cached_property
+    def selected_obj(self):
         if self.is_multiselect:
-            subset_states = {}
-            for select_subset in self.selected:
-                if select_subset == self.default_text:
-                    continue
-                subset_group = [s for s in self.app.data_collection.subset_groups if
-                                s.label == select_subset][0]
-                subset_states[select_subset] = subset_group.subset_state
-            return subset_states
+            return [self._get_selected_obj(subset) for subset in self.selected]
+        return self._get_selected_obj(self.selected)
+
+    def _get_subset_state(self, subset):
         subset_group = [s for s in self.app.data_collection.subset_groups if
-                        s.label == self.selected][0]
-        return subset_group.subset_state
+                        s.label == subset]
+        if len(subset_group) == 0:
+            return None
+        if len(subset_group) != 1:  # pragma: no cover
+            raise ValueError("found multiple matches for subset")
+        return subset_group[0].subset_state
 
-    @property
-    def selected_subset_mask(self):
+    @cached_property
+    def selected_subset_state(self):
         if self.is_multiselect:
-            raise NotImplementedError("Retrieving subset mask is not"
-                                      " supported in multiselect mode")
-        get_data_kwargs = {'data_label': self.plugin.dataset.selected}
+            return [self._get_subset_state(subset) for subset in self.selected]
+        return self._get_subset_state(self.selected)
+
+    def _get_subset_mask(self, subset=None, dataset=None):
+        if subset is None:
+            subset = self.selected
+        if dataset is None:
+            if getattr(self.plugin, 'dataset', None) is None:  # pragma: no cover
+                raise ValueError("Retrieving subset mask requires associated dataset")
+            dataset = self.plugin.dataset.selected
+        get_data_kwargs = {'data_label': dataset}
         if 'is_spectral' in self.filters:
-            get_data_kwargs['spectral_subset'] = self.selected
+            get_data_kwargs['spectral_subset'] = subset
         elif 'is_spatial' in self.filters:
-            get_data_kwargs['spatial_subset'] = self.selected
+            get_data_kwargs['spatial_subset'] = subset
 
         if self.app.config == 'cubeviz' and 'is_spectral' in self.filters:
             viewer_ref = getattr(self.plugin,
@@ -1557,15 +1589,56 @@ def selected_subset_mask(self):
             get_data_kwargs['function'] = self.app.get_viewer(viewer_ref).state.function
 
         subset = self.app._jdaviz_helper.get_data(**get_data_kwargs)
-
         return subset.mask
 
-    def selected_min_max(self, spectrum1d):
+    @cached_property
+    def selected_subset_mask(self):
+        if self.is_multiselect:  # pragma: no cover
+            raise NotImplementedError("Retrieving subset mask is not"
+                                      " supported in multiselect mode")
+
+        return self._get_subset_mask()
+
+    def _get_spatial_region(self, dataset, subset=None):
+        if subset is None:
+            subset = self.selected
+            subset_state = self.selected_subset_state
+        else:
+            subset_state = self._get_subset_state(subset)
+        region = _get_region_from_spatial_subset(self.plugin,
+                                                 subset_state,
+                                                 dataset=dataset)
+        region.meta['label'] = subset
+        return region
+
+    @cached_property
+    def selected_spatial_region(self):
+        if not getattr(self, 'dataset', None):  # pragma: no cover
+            raise ValueError("Retrieving subset mask requires associated dataset")
+        if self.is_multiselect and self.dataset.is_multiselect:  # pragma: no cover
+            # technically this could work if either has length of one, but would require extra
+            # logic
+            raise NotImplementedError("cannot access selected_spatial_region for multiple subsets and multiple datasets")  # noqa
+        types = self.selected_item.get('type')
+        if not isinstance(types, list):
+            types = [types]
+        if np.any([type != 'spatial' for type in types]):
+            raise TypeError("This action is only supported on spatial-type subsets")
         if self.is_multiselect:
+            return [self._get_spatial_region(dataset=self.dataset.selected, subset=subset) for subset in self.selected]  # noqa
+        return self._get_spatial_region(dataset=self.dataset.selected)
+
+    def selected_min_max(self, dataset):
+        """
+        Get the min/max spectral range of ``dataset`` given the selected spectral subset
+        """
+        if self.is_multiselect:  # pragma: no cover
             raise TypeError("This action cannot be done when multiselect is active")
+        if not isinstance(dataset, Spectrum1D):  # pragma: no cover
+            raise TypeError("dataset must be a Spectrum1D object")
 
         if self.selected_obj is None:
-            return np.nanmin(spectrum1d.spectral_axis), np.nanmax(spectrum1d.spectral_axis)
+            return np.nanmin(dataset.spectral_axis), np.nanmax(dataset.spectral_axis)
         if self.selected_item.get('type') != 'spectral':
             raise TypeError("This action is only supported on spectral-type subsets")
         else:
@@ -1597,7 +1670,7 @@ class SpectralSubsetSelectMixin(VuetifyTemplate, HubListener):
 
     """
     spectral_subset_items = List().tag(sync=True)
-    spectral_subset_selected = Unicode().tag(sync=True)
+    spectral_subset_selected = Any().tag(sync=True)
     spectral_subset_selected_has_subregions = Bool(False).tag(sync=True)
 
     def __init__(self, *args, **kwargs):
@@ -1607,6 +1680,7 @@ def __init__(self, *args, **kwargs):
                                             'spectral_subset_items',
                                             'spectral_subset_selected',
                                             'spectral_subset_selected_has_subregions',
+                                            dataset='dataset' if hasattr(self, 'dataset') else None,  # noqa
                                             viewers=[spectrum_viewer],
                                             default_text='Entire Spectrum',
                                             filters=['is_spectral'])
@@ -1636,7 +1710,7 @@ class SpatialSubsetSelectMixin(VuetifyTemplate, HubListener):
 
     """
     spatial_subset_items = List().tag(sync=True)
-    spatial_subset_selected = Unicode().tag(sync=True)
+    spatial_subset_selected = Any().tag(sync=True)
     spatial_subset_selected_has_subregions = Bool(False).tag(sync=True)
 
     def __init__(self, *args, **kwargs):
@@ -1645,6 +1719,7 @@ def __init__(self, *args, **kwargs):
                                            'spatial_subset_items',
                                            'spatial_subset_selected',
                                            'spatial_subset_selected_has_subregions',
+                                           dataset='dataset' if hasattr(self, 'dataset') else None,
                                            default_text='Entire Cube',
                                            filters=['is_spatial'])
 
@@ -1663,7 +1738,9 @@ class DatasetSpectralSubsetValidMixin(VuetifyTemplate, HubListener):
 
     @observe("dataset_selected", "spectral_subset_selected")
     def _check_dataset_spectral_subset_valid(self, event={}, return_ranges=False):
-
+        if not hasattr(self, 'dataset'):
+            # plugin not fully initialized
+            return
         if self.spectral_subset_selected == "Entire Spectrum":
             self.spectral_subset_valid = True
         else:
@@ -1993,6 +2070,7 @@ class DatasetSelect(SelectPluginComponent):
 
     """
     def __init__(self, plugin, items, selected,
+                 multiselect=None,
                  filters=['not_from_plugin_model_fitting', 'layer_in_viewers'],
                  default_text=None, manual_options=[],
                  default_mode='first'):
@@ -2005,6 +2083,8 @@ def __init__(self, plugin, items, selected,
             the name of the items traitlet defined in ``plugin``
         selected : str
             the name of the selected traitlet defined in ``plugin``
+        multiselect : str
+            the name of the traitlet defining whether the dropdown should accept multiple selections
         filters : list
             list of strings (for built-in filters) or callables to filter to only valid options.
         default_text : str or None
@@ -2015,7 +2095,8 @@ def __init__(self, plugin, items, selected,
             ``default`` text is provided but not in ``manual_options`` it will still be included as
             the first item in the list.
         """
-        super().__init__(plugin, items=items, selected=selected, filters=filters,
+        super().__init__(plugin, items=items, selected=selected,
+                         multiselect=multiselect, filters=filters,
                          default_text=default_text, manual_options=manual_options,
                          default_mode=default_mode)
         self._cached_properties += ["selected_dc_item"]
@@ -2053,19 +2134,27 @@ def _subset_update(msg):
     @property
     def default_data_cls(self):
         if self.app.config == 'imviz':
-            return None
+            return NDData
         if 'is_trace' in self.filters:
             return None
         return Spectrum1D
 
-    @cached_property
-    def selected_dc_item(self):
-        if self.selected not in self.labels:
+    def _get_dc_item(self, selected):
+        if selected not in self.labels:
             # _apply_default_selection will override shortly anyways
             return None
-        return next((x for x in self.app.data_collection if x.label == self.selected))
+        return next((x for x in self.app.data_collection if x.label == selected))
+
+    @cached_property
+    def selected_dc_item(self):
+        if self.is_multiselect:
+            return [self._get_dc_item(selected) for selected in self.selected]
+        return self._get_dc_item(self.selected)
 
     def get_object(self, *args, **kwargs):
+        if self.is_multiselect:
+            return [dc_item.get_object(*args, **kwargs) for dc_item in self.selected_dc_item]
+
         if self.selected not in self.labels:
             # _apply_default_selection will override shortly anyways
             return None
@@ -2073,12 +2162,13 @@ def get_object(self, *args, **kwargs):
 
     @cached_property
     def selected_obj(self):
-        if self.selected not in self.labels:
-            # _apply_default_selection will override shortly anyways
-            return None
-        match = self.app._jdaviz_helper.get_data(data_label=self.selected)
-        if match is not None:
-            return match
+        if not self.is_multiselect:
+            if self.selected not in self.labels:
+                # _apply_default_selection will override shortly anyways
+                return None
+            match = self.app._jdaviz_helper.get_data(data_label=self.selected)
+            if match is not None:
+                return match
         # handle the case of empty Application with no viewer, we'll just pull directly
         # from the data collection
         return self.get_object(cls=self.default_data_cls)
@@ -2191,7 +2281,43 @@ class DatasetSelectMixin(VuetifyTemplate, HubListener):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         # NOTE: cannot be named self.data or will conflict with existing self.data traitlet!
-        self.dataset = DatasetSelect(self, 'dataset_items', 'dataset_selected')
+        self.dataset = DatasetSelect(self, 'dataset_items', 'dataset_selected',
+                                     multiselect=None)
+
+
+class DatasetMultiSelectMixin(VuetifyTemplate, HubListener):
+    """
+    Applies the DatasetSelect component as a mixin in the base plugin with togglable multiselect.
+    This automatically adds traitlets as well as new properties to the plugin with minimal
+    extra code.  For multiple instances or custom traitlet names/defaults, use the
+    component instead.
+
+    To use in a plugin:
+
+    * add ``DatasetMultiSelectMixin`` as a mixin to the class
+    * use the traitlets available from the plugin or properties/methods available from
+      ``plugin.dataset``.
+
+    Example template (label and hint are optional)::
+
+      <plugin-dataset-select
+        :items="dataset_items"
+        :selected.sync="dataset_selected"
+        :multiselect="multiselect"
+        label="Data"
+        hint="Select data."
+      />
+
+    """
+    dataset_items = List().tag(sync=True)
+    dataset_selected = Any().tag(sync=True)
+    multiselect = Bool(False).tag(sync=True)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # NOTE: cannot be named self.data or will conflict with existing self.data traitlet!
+        self.dataset = DatasetSelect(self, 'dataset_items', 'dataset_selected',
+                                     multiselect='multiselect')  # noqa
 
 
 class AutoTextField(BasePluginComponent):
diff --git a/notebooks/concepts/imviz_advanced_aper_phot.ipynb b/notebooks/concepts/imviz_advanced_aper_phot.ipynb
index 588a69da1b..ce5d1b9706 100644
--- a/notebooks/concepts/imviz_advanced_aper_phot.ipynb
+++ b/notebooks/concepts/imviz_advanced_aper_phot.ipynb
@@ -237,7 +237,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "phot_plugin = imviz.plugins[\"Imviz Simple Aperture Photometry\"]._obj"
+    "phot_plugin = imviz.plugins[\"Aperture Photometry\"]._obj"
    ]
   },
   {
@@ -255,10 +255,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "phot_plugin.subset_selected = \"Subset 1\"\n",
-    "#phot_plugin.subset_selected = \"Subset 2\"\n",
-    "#phot_plugin.subset_selected = \"Subset 3\"\n",
-    "#phot_plugin.subset_selected = \"Subset 4\""
+    "phot_plugin.aperture_selected = \"Subset 1\"\n",
+    "#phot_plugin.aperture_selected = \"Subset 2\"\n",
+    "#phot_plugin.aperture_selected = \"Subset 3\"\n",
+    "#phot_plugin.aperture_selected = \"Subset 4\""
    ]
   },
   {
@@ -278,7 +278,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "phot_plugin.bg_subset_selected = 'Manual'\n",
+    "phot_plugin.background_selected = 'Manual'\n",
     "phot_plugin.background_value = 5.0\n",
     "\n",
     "phot_plugin.dataset_selected = \"gauss100_fits_wcs[PRIMARY,1]\"\n",
diff --git a/notebooks/concepts/imviz_simple_aper_phot.ipynb b/notebooks/concepts/imviz_simple_aper_phot.ipynb
index 2144892879..cca9f52586 100644
--- a/notebooks/concepts/imviz_simple_aper_phot.ipynb
+++ b/notebooks/concepts/imviz_simple_aper_phot.ipynb
@@ -5,7 +5,7 @@
    "id": "65797402-e16b-4a78-8acc-02dd90ca5e7d",
    "metadata": {},
    "source": [
-    "# Imviz simple aperture photometry\n",
+    "# Aperture Photometry\n",
     "\n",
     "This is a proof-of-concept showing how to use Imviz to perform simple aperture photometry using hand-drawn aperture on a single object."
    ]
@@ -163,7 +163,7 @@
    "id": "9abeb637-dac2-4787-8087-3be5f54a5dd0",
    "metadata": {},
    "source": [
-    "Now, use the \"Imviz Simple Aperture Photometry\" plugin.\n",
+    "Now, use the \"Aperture Photometry\" plugin.\n",
     "\n",
     "Once photometry is done, we would do the following to extract the data from Imviz back to notebook for further processing."
    ]