diff --git a/client/dive-common/apispec.ts b/client/dive-common/apispec.ts
index 1c7dee2f4..9d751ff10 100644
--- a/client/dive-common/apispec.ts
+++ b/client/dive-common/apispec.ts
@@ -125,7 +125,7 @@ interface Api {
   saveMetadata(datasetId: string, metadata: DatasetMetaMutable): Promise<unknown>;
   saveAttributes(datasetId: string, args: SaveAttributeArgs): Promise<unknown>;
   // Non-Endpoint shared functions
-  openFromDisk(datasetType: DatasetType | 'calibration' | 'annotation' | 'text', directory?: boolean):
+  openFromDisk(datasetType: DatasetType | 'calibration' | 'annotation' | 'text' | 'zip', directory?: boolean):
     Promise<{canceled?: boolean; filePaths: string[]; fileList?: File[]; root?: string}>;
   importAnnotationFile(id: string, path: string, file?: File): Promise<boolean>;
 }
diff --git a/client/dive-common/components/ImportButton.vue b/client/dive-common/components/ImportButton.vue
index e203d1382..577b870b9 100644
--- a/client/dive-common/components/ImportButton.vue
+++ b/client/dive-common/components/ImportButton.vue
@@ -20,7 +20,7 @@ export default defineComponent({
       required: true,
     },
     openType: {
-      type: String as PropType<DatasetType>,
+      type: String as PropType<DatasetType | 'zip'>,
       required: true,
     },
     multiCamImport: { //TODO: Temporarily used to hide the stereo settings from users
@@ -31,6 +31,10 @@ export default defineComponent({
       type: Object,
       default: () => DefaultButtonAttrs,
     },
+    small: { // Smaller setting for "Add Another ..."
+      type: Boolean,
+      default: false,
+    },
   },
   setup() {
     return {
@@ -50,7 +54,8 @@ export default defineComponent({
       <template v-slot:activator="{ on }">
         <v-btn
           v-bind="buttonAttrs"
-          large
+          :large="!small"
+          :small="small"
           class="px-0"
           @click="$emit('open', openType)"
         >
diff --git a/client/dive-common/constants.ts b/client/dive-common/constants.ts
index cb3017232..192d2c4c5 100644
--- a/client/dive-common/constants.ts
+++ b/client/dive-common/constants.ts
@@ -100,6 +100,10 @@ const listFileTypes = [
   'txt',
 ];
 
+const zipFileTypes = [
+  'zip',
+];
+
 const stereoPipelineMarker = 'measurement';
 const multiCamPipelineMarkers = ['2-cam', '3-cam'];
 
@@ -121,6 +125,7 @@ export {
   inputAnnotationTypes,
   inputAnnotationFileTypes,
   listFileTypes,
+  zipFileTypes,
   stereoPipelineMarker,
   multiCamPipelineMarkers,
 };
diff --git a/client/platform/web-girder/utils.ts b/client/platform/web-girder/utils.ts
index 8daac9086..a2675670e 100644
--- a/client/platform/web-girder/utils.ts
+++ b/client/platform/web-girder/utils.ts
@@ -1,6 +1,6 @@
 import {
   calibrationFileTypes, inputAnnotationFileTypes, inputAnnotationTypes,
-  otherImageTypes, otherVideoTypes, websafeImageTypes, websafeVideoTypes,
+  otherImageTypes, otherVideoTypes, websafeImageTypes, websafeVideoTypes, zipFileTypes,
 } from 'dive-common/constants';
 import { DatasetType } from 'dive-common/apispec';
 import type { LocationType, RootlessLocationType } from 'platform/web-girder/store/types';
@@ -34,12 +34,12 @@ function getRouteFromLocation(location: LocationType): string {
   return `/${location._modelType}/${location._id}`;
 }
 
-async function openFromDisk(datasetType: DatasetType | 'calibration' | 'annotation'):
+async function openFromDisk(datasetType: DatasetType | 'calibration' | 'annotation' | 'zip'):
 Promise<{ canceled: boolean; filePaths: string[]; fileList?: File[]}> {
   const input: HTMLInputElement = document.createElement('input');
   input.type = 'file';
   const baseTypes: string[] = inputAnnotationFileTypes.map((item) => `.${item}`);
-  if (!['calbiration', 'annotation'].includes(datasetType)) {
+  if (!['calbiration', 'annotation', 'zip'].includes(datasetType)) {
     input.multiple = true;
   }
   if (datasetType === 'image-sequence') {
@@ -51,6 +51,8 @@ Promise<{ canceled: boolean; filePaths: string[]; fileList?: File[]}> {
   } else if (datasetType === 'annotation') {
     input.accept = inputAnnotationTypes
       .concat(inputAnnotationFileTypes.map((item) => `.${item}`)).join(',');
+  } else if (datasetType === 'zip') {
+    input.accept = zipFileTypes.map((item) => `.${item}`).join(',');
   }
 
   return new Promise(((resolve) => {
diff --git a/client/platform/web-girder/views/Upload.vue b/client/platform/web-girder/views/Upload.vue
index efcc101af..511733ab9 100644
--- a/client/platform/web-girder/views/Upload.vue
+++ b/client/platform/web-girder/views/Upload.vue
@@ -38,7 +38,7 @@ export interface PendingUpload {
   meta: null | File;
   annotationFile: null | File;
   mediaList: File[];
-  type: DatasetType;
+  type: DatasetType | 'zip';
   fps: number;
   uploading: boolean;
 }
@@ -70,29 +70,63 @@ export default defineComponent({
     const importMultiCamDialog = ref(false);
     const girderUpload: Ref<null | GirderUpload> = ref(null);
     const { prompt } = usePrompt();
-    /**
-     * Initial opening of file dialog
-     */
-    const openImport = async (dstype: DatasetType) => {
-      const ret = await openFromDisk(dstype);
-      if (!ret.canceled && ret.fileList) {
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        const processed = processImport(ret);
-        if (processed?.fullList?.length === 0) return;
-        if (processed && processed.fullList) {
-          const name = processed.fullList.length === 1 ? processed.fullList[0].name : '';
-          preUploadErrorMessage.value = null;
-          try {
-            // eslint-disable-next-line @typescript-eslint/no-use-before-define
-            await addPendingUpload(
-              name, processed.fullList, processed.metaFile,
-              processed.annotationFile, processed.mediaList,
-            );
-          } catch (err) {
-            preUploadErrorMessage.value = err.response?.data?.message || err;
-          }
+
+    const addPendingZipUpload = (name: string, allFiles: File[]) => {
+      const fps = clientSettings.annotationFPS || DefaultVideoFPS;
+      const defaultFilename = allFiles.length ? allFiles[0].name.replace(/\..*/, '') : 'Zip Upload';
+      pendingUploads.value.push({
+        createSubFolders: false,
+        name: defaultFilename,
+        files: [], //Will be set in the GirderUpload Component
+        meta: null,
+        annotationFile: null,
+        mediaList: allFiles,
+        type: 'zip',
+        fps,
+        uploading: false,
+      });
+    };
+
+    const addPendingUpload = async (
+      name: string,
+      allFiles: File[],
+      meta: File | null,
+      annotationFile: File | null,
+      mediaList: File[],
+    ) => {
+      const resp = (await validateUploadGroup(allFiles.map((f) => f.name))).data;
+      if (!resp.ok) {
+        if (resp.message) {
+          preUploadErrorMessage.value = resp.message;
+        }
+        throw new Error(resp.message);
+      }
+      const fps = clientSettings.annotationFPS || DefaultVideoFPS;
+      const defaultFilename = resp.media[0];
+      const validFiles = resp.media.concat(resp.annotations);
+      // mapping needs to be done for the mixin upload functions
+      const internalFiles = allFiles
+        .filter((f) => validFiles.includes(f.name));
+      let createSubFolders = false;
+      if (resp.type === 'video') {
+        if (resp.media.length > 1) {
+          createSubFolders = true;
         }
       }
+      pendingUploads.value.push({
+        createSubFolders,
+        name:
+          internalFiles.length > 1
+            ? defaultFilename.replace(/\..*/, '')
+            : defaultFilename,
+        files: [], //Will be set in the GirderUpload Component
+        meta,
+        annotationFile,
+        mediaList,
+        type: resp.type,
+        fps,
+        uploading: false,
+      });
     };
     /**
      * Processes the imported media files to distinguish between
@@ -157,6 +191,32 @@ export default defineComponent({
       }
       return output;
     };
+    /**
+     * Initial opening of file dialog
+     */
+    const openImport = async (dstype: DatasetType | 'zip') => {
+      const ret = await openFromDisk(dstype);
+      if (!ret.canceled && ret.fileList) {
+        const processed = processImport(ret);
+        if (processed?.fullList?.length === 0) return;
+        if (processed && processed.fullList) {
+          const name = processed.fullList.length === 1 ? processed.fullList[0].name : '';
+          preUploadErrorMessage.value = null;
+          try {
+            if (dstype !== 'zip') {
+              await addPendingUpload(
+                name, processed.fullList, processed.metaFile,
+                processed.annotationFile, processed.mediaList,
+              );
+            } else {
+              addPendingZipUpload(name, processed.fullList);
+            }
+          } catch (err) {
+            preUploadErrorMessage.value = err.response?.data?.message || err;
+          }
+        }
+      }
+    };
     const openMultiCamDialog = (args: { stereo: boolean; openType: 'image-sequence' | 'video' }) => {
       stereo.value = args.stereo;
       multiCamOpenType.value = args.openType;
@@ -204,7 +264,7 @@ export default defineComponent({
           return `${filesNotUploaded(pendingUpload)} files`;
         } if (pendingUpload.type === VideoType && !pendingUpload.uploading) {
           return `${filesNotUploaded(pendingUpload)} videos`;
-        } if (pendingUpload.type === VideoType && pendingUpload.uploading) {
+        } if ((pendingUpload.type === VideoType || pendingUpload.type === 'zip') && pendingUpload.uploading) {
           // For videos we display the total progress when uploading because
           // single videos can be large
           return `${formatSize(totalProgress)} of ${formatSize(totalSize)}`;
@@ -219,52 +279,14 @@ export default defineComponent({
       return `Folder Name${plural}`;
     };
     const getFilenameInputStateDisabled = (pendingUpload: PendingUpload) => (
-      pendingUpload.uploading || pendingUpload.createSubFolders
+      pendingUpload.uploading || (pendingUpload.createSubFolders && pendingUpload.type !== 'zip')
     );
     const getFilenameInputStateHint = (pendingUpload: PendingUpload) => (
-      pendingUpload.createSubFolders ? 'default folder names are used when "Create Subfolders" is selected' : ''
+      (pendingUpload.createSubFolders && pendingUpload.type !== 'zip') ? 'default folder names are used when "Create Subfolders" is selected' : ''
+    );
+    const getFilenameInputValue = (pendingUpload: PendingUpload) => (
+      pendingUpload.createSubFolders && pendingUpload.type !== 'zip' ? 'default' : pendingUpload.name
     );
-    const addPendingUpload = async (
-      name: string,
-      allFiles: File[],
-      meta: File | null,
-      annotationFile: File | null,
-      mediaList: File[],
-    ) => {
-      const resp = (await validateUploadGroup(allFiles.map((f) => f.name))).data;
-      if (!resp.ok) {
-        if (resp.message) {
-          preUploadErrorMessage.value = resp.message;
-        }
-        throw new Error(resp.message);
-      }
-      const fps = clientSettings.annotationFPS || DefaultVideoFPS;
-      const defaultFilename = resp.media[0];
-      const validFiles = resp.media.concat(resp.annotations);
-      // mapping needs to be done for the mixin upload functions
-      const internalFiles = allFiles
-        .filter((f) => validFiles.includes(f.name));
-      let createSubFolders = false;
-      if (resp.type === 'video') {
-        if (resp.media.length > 1) {
-          createSubFolders = true;
-        }
-      }
-      pendingUploads.value.push({
-        createSubFolders,
-        name:
-          internalFiles.length > 1
-            ? defaultFilename.replace(/\..*/, '')
-            : defaultFilename,
-        files: [], //Will be set in the GirderUpload Component
-        meta,
-        annotationFile,
-        mediaList,
-        type: resp.type,
-        fps,
-        uploading: false,
-      });
-    };
     const remove = (pendingUpload: PendingUpload) => {
       const index = pendingUploads.value.indexOf(pendingUpload);
       pendingUploads.value.splice(index, 1);
@@ -323,6 +345,7 @@ export default defineComponent({
       multiCamImport,
       computeUploadProgress,
       getFilenameInputStateLabel,
+      getFilenameInputValue,
       getFilenameInputStateDisabled,
       getFilenameInputStateHint,
       addPendingUpload,
@@ -395,7 +418,7 @@ export default defineComponent({
             <v-row class="align-center">
               <v-col class="py-0">
                 <v-text-field
-                  :value="pendingUpload.createSubFolders ? 'default' : pendingUpload.name"
+                  :value="getFilenameInputValue(pendingUpload)"
                   class="upload-name"
                   :rules="[val => (val || '').length > 0 || 'This field is required']"
                   required
@@ -439,7 +462,7 @@ export default defineComponent({
                 </v-btn>
               </v-col>
             </v-row>
-            <v-row v-if="!pendingUpload.createSubFolders">
+            <v-row v-if="!pendingUpload.createSubFolders && pendingUpload.type !== 'zip'">
               <v-col class="py-0">
                 <v-row>
                   <v-col>
@@ -504,6 +527,7 @@ export default defineComponent({
               icon="mdi-folder-open"
               open-type="image-sequence"
               class="grow"
+              :small="!!pendingUploads.length"
               :class="[pendingUploads.length ? 'mr-3' : 'my-3']"
               :button-attrs="buttonAttrs"
               @open="openImport($event)"
@@ -513,12 +537,23 @@ export default defineComponent({
               :name="`Add ${pendingUploads.length ? 'Another ' : ''}Video`"
               icon="mdi-file-video"
               class="grow"
+              :small="!!pendingUploads.length"
               :class="[pendingUploads.length ? 'ml-3' : 'my-3']"
               open-type="video"
               :button-attrs="buttonAttrs"
               @open="openImport($event)"
               @multi-cam="openMultiCamDialog"
             />
+            <import-button
+              :name="`Add ${pendingUploads.length ? 'Another ' : ''}Zip File`"
+              icon="mdi-zip-box"
+              class="grow"
+              :small="!!pendingUploads.length"
+              :class="[pendingUploads.length ? 'ml-3' : 'my-3']"
+              open-type="zip"
+              :button-attrs="buttonAttrs"
+              @open="openImport($event)"
+            />
           </div>
           <v-btn
             v-if="pendingUploads.length"
diff --git a/docs/Web-Version.md b/docs/Web-Version.md
index 6ceb63bae..6c3c1121c 100644
--- a/docs/Web-Version.md
+++ b/docs/Web-Version.md
@@ -34,6 +34,17 @@ A user account is required to store data and run pipelines on viame.kitware.com.
 * Choose a name for the data, enter the optional video playback frame rate, and press start-upload.
 * In the data browser, a new blue "Launch Annotator" button will appear next to your data.
 
+### Zip Files
+
+A zip import can have one of the following file combinations:
+
+* One or more images, an optional annotation file, and an optional configuration file
+* One video with an optional annotation file and an optional configuration file
+* One or more folders which contain the above examples (These will be converted to separate datasets)
+
+Zip import also accepts zip archive files that were generated by DIVE Web's `Download -> Everything` export button.
+
+
 !!! info
 
     All video uploaded to the web server will be transcoded as `mp4/h264`.
diff --git a/server/dive_server/crud.py b/server/dive_server/crud.py
index 6c69a22e5..0255a780b 100644
--- a/server/dive_server/crud.py
+++ b/server/dive_server/crud.py
@@ -102,7 +102,9 @@ def get_static_pipelines_path() -> Path:
 
 
 def get_or_create_auxiliary_folder(folder, user):
-    return Folder().createFolder(folder, "auxiliary", reuseExisting=True, creator=user)
+    return Folder().createFolder(
+        folder, constants.AuxiliaryFolderName, reuseExisting=True, creator=user
+    )
 
 
 def move_existing_result_to_auxiliary_folder(folder, user):
@@ -111,6 +113,10 @@ def move_existing_result_to_auxiliary_folder(folder, user):
         Item().move(item, auxiliary)
 
 
+def get_or_create_source_folder(folder, user):
+    return Folder().createFolder(folder, "source", reuseExisting=True, creator=user)
+
+
 def itemIsWebsafeVideo(item: Item) -> bool:
     return fromMeta(item, "codec") == "h264"
 
diff --git a/server/dive_server/crud_rpc.py b/server/dive_server/crud_rpc.py
index 8a5a41088..cdf6279b9 100644
--- a/server/dive_server/crud_rpc.py
+++ b/server/dive_server/crud_rpc.py
@@ -368,12 +368,12 @@ def postprocess(
         Transcoding of Video
         Transcoding of Images
         Conversion of KPF annotations into track JSON
+        Extraction and upload of zip files
 
     In either case, the following may run synchronously:
         Conversion of CSV annotations into track JSON
     """
     job_is_private = user.get(constants.UserPrivateQueueEnabledMarker, False)
-    auxiliary = crud.get_or_create_auxiliary_folder(dsFolder, user)
     isClone = fromMeta(dsFolder, constants.ForeignMediaIdMarker, None) is not None
     # add default confidence filter threshold to folder metadata
     dsFolder['meta'][constants.ConfidenceFiltersMarker] = {'default': 0.1}
@@ -386,6 +386,34 @@ def postprocess(
 
     if not skipJobs and not isClone:
         token = Token().createToken(user=user, days=2)
+
+        # extract ZIP Files if not already completed
+        zipItems = list(
+            Folder().childItems(
+                dsFolder,
+                filters={"lowerName": {"$regex": constants.zipRegex}},
+            )
+        )
+        if len(zipItems) > 1:
+            raise RestException('There are multiple zip files in the folder.')
+        for item in zipItems:
+            total_items = len(list((Folder().childItems(dsFolder))))
+            if total_items > 1:
+                raise RestException('There are multiple files besides a zip, cannot continue')
+            newjob = tasks.extract_zip.apply_async(
+                queue=_get_queue_name(user),
+                kwargs=dict(
+                    folderId=str(item["folderId"]),
+                    itemId=str(item["_id"]),
+                    girder_job_title=f"Extracting {item['_id']} to folder {str(dsFolder['_id'])}",
+                    girder_client_token=str(token["_id"]),
+                    girder_job_type="private" if job_is_private else "convert",
+                ),
+            )
+            newjob.job[constants.JOBCONST_PRIVATE_QUEUE] = job_is_private
+            Job().save(newjob.job)
+            return dsFolder
+
         # transcode VIDEO if necessary
         videoItems = Folder().childItems(
             dsFolder, filters={"lowerName": {"$regex": constants.videoRegex}}
@@ -442,6 +470,7 @@ def make_file_generator(item):
             allFiles = [make_file_generator(item) for item in ymlItems]
             crud.saveTracks(dsFolder, meva.load_kpf_as_tracks(allFiles), user)
             ymlItems.rewind()
+            auxiliary = crud.get_or_create_auxiliary_folder(dsFolder, user)
             for item in ymlItems:
                 Item().move(item, auxiliary)
 
diff --git a/server/dive_tasks/tasks.py b/server/dive_tasks/tasks.py
index 0603ed450..0762ebedb 100644
--- a/server/dive_tasks/tasks.py
+++ b/server/dive_tasks/tasks.py
@@ -125,7 +125,7 @@ def upgrade_pipelines(
     addons_to_update_update: List[Path] = []
 
     for addon in urls:
-        download_name = urlparse(addon).path.replace('/', '_')
+        download_name = urlparse(addon).path.replace(os.path.sep, '_')
         zipfile_path = conf.addon_zip_path / f'{download_name}.zip'
         if not zipfile_path.exists() or force:
             # Update the zipfile if force option set or file not exists
@@ -556,3 +556,100 @@ def convert_images(self: Task, folderId):
             str(folderId),
             {"annotate": True},  # mark the parent folder as able to annotate.
         )
+
+
+@app.task(bind=True, acks_late=True, ignore_result=True)
+def extract_zip(self: Task, folderId: str, itemId: str):
+    """
+    Discovery logic:
+    * Find all folders that have at least one child file (potential datasets)
+    * Exclude folders which are sub-folders of previously discovered folders
+      because datasets cannot be nested in other datasets
+    """
+    context: dict = {}
+    gc: GirderClient = self.girder_client
+    manager: JobManager = patch_manager(self.job_manager)
+    if utils.check_canceled(self, context):
+        manager.updateStatus(JobStatus.CANCELED)
+        return
+
+    with tempfile.TemporaryDirectory() as _working_directory, suppress(utils.CanceledError):
+        _working_directory_path = Path(_working_directory)
+        item: GirderModel = gc.getItem(itemId)
+        file_name = str(_working_directory_path / item['name'])
+        manager.write(f'Fetching input from {itemId} to {file_name}...\n')
+        gc.downloadItem(itemId, _working_directory, item["name"])
+        discovered_folders = {}
+        with zipfile.ZipFile(file_name, 'r') as zipObj:
+            listOfFileNames = zipObj.namelist()
+            sum_file_size = sum([data.file_size for data in zipObj.filelist])
+            sum_compress_size = sum([data.compress_size for data in zipObj.filelist])
+            ratio = sum_file_size / sum_compress_size
+            if ratio > 600:
+                manager.write(
+                    f"Compression ratio is exceedingly high at {ratio}\n\
+                    Please contact an admin at viame-web@kitware.com if this is a valid zip file"
+                )
+                raise Exception("High Compression Ratio for Zip File")
+
+            for fileName in listOfFileNames:
+                folderName = os.path.dirname(fileName)
+                parentName = os.path.dirname(folderName)
+                if parentName in discovered_folders and folderName != '':
+                    discovered_folders[folderName] = 'ignored'
+                    continue
+                if fileName.endswith(os.path.sep):
+                    continue
+                if folderName not in discovered_folders:
+                    discovered_folders[folderName] = 'unstructured'
+                if os.path.basename(fileName) == constants.MetaFileName:
+                    # sub folder has a meta.json so it is an exported dataset
+                    discovered_folders[folderName] = 'dataset'
+                if fileName.endswith('.zip'):
+                    raise Exception("Nested Zip Files are invalid")
+                manager.write(f"Extracting: {fileName}\n")
+                zipObj.extract(fileName, f'{_working_directory}')
+
+        # remove the zip file so it isn't uploaded back to the folder
+        os.remove(file_name)
+        # Create source folder and move zip file there
+        created_folder = gc.createFolder(
+            folderId,
+            constants.SourceFolderName,
+            reuseExisting=True,
+        )
+        gc.sendRestRequest(
+            "PUT",
+            f"/item/{str(item['_id'])}?folderId={str(created_folder['_id'])}",
+        )
+        # Only make subfolders if more than 1 discovered folder exists
+        make_subfolders = (
+            len(discovered_folders) - list(discovered_folders.values()).count('ignored')
+        ) > 1
+        for folderName, folderType in discovered_folders.items():
+            subFolderName = folderName if make_subfolders else ''
+            if folderType == 'unstructured':
+                utils.upload_zipped_flat_media_files(
+                    gc,
+                    manager,
+                    folderId,
+                    _working_directory_path / folderName,
+                    subFolderName,
+                )
+            elif folderType == 'dataset':
+                utils.upload_exported_zipped_dataset(
+                    gc,
+                    manager,
+                    folderId,
+                    _working_directory_path / folderName,
+                    subFolderName,
+                )
+            else:
+                manager.write(f'Ignoring {folderName}\n')
+
+        if make_subfolders:
+            gc.sendRestRequest(
+                "DELETE",
+                f"folder/{folderId}/metadata",
+                json=[constants.TypeMarker, constants.FPSMarker, constants.DatasetMarker],
+            )
diff --git a/server/dive_tasks/utils.py b/server/dive_tasks/utils.py
index bacf16d2b..8b443a78a 100644
--- a/server/dive_tasks/utils.py
+++ b/server/dive_tasks/utils.py
@@ -1,4 +1,6 @@
 from datetime import datetime, timedelta
+import json
+import os
 from pathlib import Path
 import shutil
 import signal
@@ -157,3 +159,139 @@ def download_source_media(girder_client: GirderClient, datasetId: str, dest: Pat
         return [destination_path]
     else:
         raise Exception(f"unexpected metadata {str(dataset.dict())}")
+
+
+def upload_zipped_flat_media_files(
+    gc: GirderClient,
+    manager: JobManager,
+    folderId: str,
+    working_directory: Path,
+    create_subfolder=False,
+):
+    """Takes a flat folder of media files and/or annotation and generates a dataset from it"""
+    listOfFileNames = os.listdir(working_directory)
+    validation = gc.sendRestRequest('POST', '/dive_dataset/validate_files', json=listOfFileNames)
+    root_folderId = folderId
+    default_fps = gc.getFolder(root_folderId).get(f"meta.{constants.FPSMarker}", -1)
+    if validation.get('ok', False):
+        manager.write(f"Annotations: {validation['annotations']}\n")
+        manager.write(f"Media: {validation['media']}\n")
+        dataset_type = validation['type']
+        manager.write(f"Type: {dataset_type}\n")
+        if create_subfolder != '':
+            sub_folder = gc.createFolder(
+                folderId,
+                create_subfolder,
+                reuseExisting=True,
+            )
+            root_folderId = str(sub_folder["_id"])
+
+        # Upload all resulting items back into the root folder
+        manager.updateStatus(JobStatus.PUSHING_OUTPUT)
+        # create a source folder to place the zipFile inside of
+        gc.upload(f'{working_directory}/*', root_folderId)
+        if dataset_type == constants.ImageSequenceType and default_fps == -1:
+            default_fps = 1
+        gc.addMetadataToFolder(
+            str(root_folderId),
+            {constants.TypeMarker: dataset_type, constants.FPSMarker: default_fps},
+        )
+        # After uploading the default files we do a the postprocess for video conversion now
+        gc.sendRestRequest("POST", f"/dive_rpc/postprocess/{str(root_folderId)}")
+    else:
+        manager.write(f"Message: {validation['message']}\n")
+        raise Exception("Could not Validate media Files")
+
+
+def upload_exported_zipped_dataset(
+    gc: GirderClient,
+    manager: JobManager,
+    folderId: str,
+    working_directory: Path,
+    create_subfolder='',
+):
+    """Uploads a folder that is generated from the export of a zip file and sets metadata"""
+    listOfFileNames = os.listdir(working_directory)
+    if constants.MetaFileName not in listOfFileNames:
+        manager.write(f"Could not find {constants.MetaFileName} file within the subdirectroy\n")
+        return
+    print(listOfFileNames)
+    # load meta.json to get datatype and verify list of files
+    meta = {}
+    with open(f"{working_directory}/{constants.MetaFileName}") as f:
+        meta = json.load(f)
+    type = meta[constants.TypeMarker]
+    if type == constants.ImageSequenceType:
+        imageData = meta['imageData']
+        for image in imageData:
+            if image["filename"] not in listOfFileNames:
+                manager.write("Could not find {item['filename']} file within the list of files\n")
+                return
+    elif type == constants.VideoType:
+        video = meta["video"]
+        if video["filename"] not in listOfFileNames:
+            manager.write("Could not find {item['filename']} file within the list of files\n")
+            return
+    # remove the auxilary directory so we don't have to tag them all
+    if constants.AuxiliaryFolderName in listOfFileNames and os.path.isdir(
+        f'{working_directory}/{constants.AuxiliaryFolderName}'
+    ):
+        shutil.rmtree(f'{working_directory}/{constants.AuxiliaryFolderName}')
+    root_folderId = folderId
+    if create_subfolder != '':
+        sub_folder = gc.createFolder(
+            folderId,
+            create_subfolder,
+            reuseExisting=True,
+        )
+        root_folderId = str(sub_folder['_id'])
+        manager.updateStatus(JobStatus.PUSHING_OUTPUT)
+        # create a source folder to place the zipFile inside of
+    gc.upload(f'{working_directory}/*', root_folderId)
+    # Now we set all the metadata for the folders and items
+    all_files = list(gc.listItem(root_folderId))
+    root_meta = {
+        "type": type,
+        "attributes": meta.get("attributes", None),
+        "customTypeStyling": meta.get("customTypeStyling", None),
+        "confidenceFilters": meta.get("confidenceFilters", None),
+        "fps": meta["fps"],
+        "version": meta["version"],
+    }
+    if type == constants.VideoType:
+        # set transcoded and non-transcoded versions
+        transcoded_video = list(gc.listItem(root_folderId, name=video["filename"]))
+        if len(transcoded_video) == 1:
+            ffprobe = meta["ffprobe_info"]
+            avgFpsString = ffprobe["avg_frame_rate"]
+            dividend, divisor = [int(v) for v in avgFpsString.split('/')]
+            originalFps = dividend / divisor
+
+            transcoded_metadata = {
+                "codec": "h264",
+                "originalFps": originalFps,
+                "originalFpsString": avgFpsString,
+                "source_video": False,
+                "transcoder": "ffmpeg",
+            }
+            gc.addMetadataToItem(str(transcoded_video[0]['_id']), transcoded_metadata)
+            # other video is tagged as the source video
+            for item in all_files:
+                if (
+                    item["name"].endswith(tuple(constants.validVideoFormats))
+                    and item["name"] != video["filename"]
+                ):
+                    source_metadata = {
+                        "codec": ffprobe["codec_name"],
+                        "originalFps": originalFps,
+                        "originalFpsString": avgFpsString,
+                        "source_video": False,
+                    }
+                    gc.addMetadataToItem(str(item['_id']), source_metadata)
+            root_meta["originalFps"] = originalFps
+            root_meta["originalFpsString"] = avgFpsString
+
+    # Need to tag folder Level data (annotate, and others)
+    root_meta[constants.DatasetMarker] = True
+    gc.addMetadataToFolder(root_folderId, root_meta)
+    gc.post(f'dive_rpc/postprocess/{root_folderId}', data={"skipJobs": True})
diff --git a/server/dive_utils/constants.py b/server/dive_utils/constants.py
index 5b3b5c391..0ee91c535 100644
--- a/server/dive_utils/constants.py
+++ b/server/dive_utils/constants.py
@@ -28,6 +28,7 @@
 csvRegex = re.compile(r"\.csv$", re.IGNORECASE)
 jsonRegex = re.compile(r"\.json$", re.IGNORECASE)
 ymlRegex = re.compile(r"\.ya?ml$", re.IGNORECASE)
+zipRegex = re.compile(r"\.zip$", re.IGNORECASE)
 
 ImageMimeTypes = {
     "image/png",
@@ -84,6 +85,12 @@
 ViameDataFolderName = "VIAME"
 # The name of the subfolder for training results
 TrainingOutputFolderName = "VIAME Training Results"
+# The name of the source folder holding zip backups
+SourceFolderName = "source"
+# The name of the auxiliary folder
+AuxiliaryFolderName = "auxiliary"
+# the name of the meta file
+MetaFileName = "meta.json"
 
 # job constants
 JOBCONST_DATASET_ID = 'datset_id'
diff --git a/server/tests/integration/conftest.py b/server/tests/integration/conftest.py
index 873275219..b2af12c70 100644
--- a/server/tests/integration/conftest.py
+++ b/server/tests/integration/conftest.py
@@ -4,6 +4,7 @@
 from typing import Any, Dict, List
 
 from girder_client import GirderClient
+from girder_worker.utils import JobStatus
 import pytest
 
 localDataRoot = Path('tests/integration/data')
@@ -13,7 +14,7 @@
 Most tests run operations on a single dataset for each user, so keeping
 each user constrained to a single data type will help ensure robustness
 """
-users: Dict[str, Dict[str, Any]] = {
+users = {
     'alice': {
         'login': 'alice',
         'email': 'alice@locahost.lan',
@@ -146,6 +147,99 @@
     },
 }
 
+zipUser = {
+    'login': 'zipUser',
+    'email': 'zipUser@locahost.lan',
+    'firstName': 'zip',
+    'lastName': 'User',
+    'password': 'zipUserPass',
+    'data': [
+        {
+            'name': 'testImageZip',
+            'path': 'zipTestFiles/testImageZip.zip',
+            'fps': 1,
+            'type': 'image-sequence',
+            'trackCount': 197,
+            'job_status': JobStatus.SUCCESS,
+        },
+        {
+            'name': 'testVideoZip',
+            'path': 'zipTestFiles/testVideoZip.zip',
+            'fps': 29.97002997002997,
+            'originalFps': 30000 / 1001,
+            'type': 'video',
+            'job_status': JobStatus.SUCCESS,
+        },
+        {
+            'name': 'SingleDatasetImport',
+            'path': 'zipTestFiles/SingleDatasetImport.zip',
+            'fps': 29.97002997002997,
+            'originalFps': 30000 / 1001,
+            'type': 'video',
+            'job_status': JobStatus.SUCCESS,
+        },
+        {
+            'name': 'flatMultiImport',
+            'path': 'zipTestFiles/flatMultiImport.zip',
+            'fps': -1,
+            'type': 'zip',
+            'subDatasets': [
+                {
+                    'name': 'testVideoZip',
+                    'type': 'video',
+                    'fps': 29.97002997002997,
+                },
+                {
+                    'name': 'testImageZip',
+                    'type': 'image-sequence',
+                    'fps': 1,
+                },
+            ],
+            'job_status': JobStatus.SUCCESS,
+        },
+        {
+            'name': 'MultiDatasetImport',
+            'path': 'zipTestFiles/MultiDatasetImport.zip',
+            'fps': -1,
+            'type': 'zip',
+            'subDatasets': [
+                {
+                    'name': 'video1_train_mp4',
+                    'type': 'video',
+                    'fps': 29.97002997002997,
+                },
+                {
+                    'name': 'testtrain1_imagelist',
+                    'type': 'image-sequence',
+                    'fps': 1,
+                },
+            ],
+            'job_status': JobStatus.SUCCESS,
+        },
+        {
+            'name': 'badFormatZip',
+            'path': 'zipTestFiles/badFormatZip.zip',
+            'fps': 1,
+            'type': 'image-sequence',
+            'job_status': JobStatus.ERROR,
+        },
+        {
+            'name': 'nestedZip',
+            'path': 'zipTestFiles/nestedZip.zip',
+            'fps': 1,
+            'type': 'image-sequence',
+            'job_status': JobStatus.ERROR,
+        },
+        {
+            'name': 'zipBomb',
+            'path': 'zipTestFiles/zipBomb.zip',
+            'fps': 1,
+            'type': 'image-sequence',
+            'job_status': JobStatus.ERROR,
+        },
+    ],
+}
+
 
 def getClient(name: str) -> GirderClient:
     gc = GirderClient(apiUrl='http://localhost:8010/api/v1')
@@ -166,7 +260,7 @@ def admin_client() -> GirderClient:
     return gc
 
 
-def wait_for_jobs(client: GirderClient, max_wait_timeout=30):
+def wait_for_jobs(client: GirderClient, max_wait_timeout=30, expected_status=JobStatus.SUCCESS):
     """Wait for all worker jobs to complete"""
     start_time = time.time()
     incompleteJobs = []
@@ -192,8 +286,8 @@ def wait_for_jobs(client: GirderClient, max_wait_timeout=30):
             'limit': 1,
         },
     )
-    if len(lastJob) > 0 and lastJob[0]['status'] != 3:
-        raise Exception("Some jobs did not succeed")
+    if len(lastJob) > 0 and lastJob[0]['status'] != expected_status:
+        raise Exception(f"Some jobs did not meet their expected status: {expected_status}")
 
 
 def match_user_server_data(user: Dict[str, Any], dataset) -> List[dict]:
diff --git a/server/tests/integration/test_download_extract.py b/server/tests/integration/test_download_extract.py
index 7322b3cdf..9a16c1b26 100644
--- a/server/tests/integration/test_download_extract.py
+++ b/server/tests/integration/test_download_extract.py
@@ -11,6 +11,7 @@
     ('607ded8b1d59f90549235c3d', 'stereo.zip'),
     ('6006dfb9f751cc24d135ec29', 'TestData.zip'),
     ('61646cf37c93704c9952e84d', 'kwcoco.zip'),
+    ('619cf1f87a958c6b1f255c2c', 'zipTestFiles.zip'),
 ]
 
 
diff --git a/server/tests/integration/test_zip_uploads.py b/server/tests/integration/test_zip_uploads.py
new file mode 100644
index 000000000..5d513fc15
--- /dev/null
+++ b/server/tests/integration/test_zip_uploads.py
@@ -0,0 +1,76 @@
+from pathlib import Path
+
+from girder_client import GirderClient, HttpError
+from girder_worker.utils import JobStatus
+import pytest
+
+from .conftest import getTestFolder, localDataRoot, wait_for_jobs, zipUser
+
+
+@pytest.mark.integration
+@pytest.mark.parametrize("user", [zipUser])
+@pytest.mark.run(order=2)
+def test_user_creation(admin_client: GirderClient, user: dict):
+    try:
+        admin_client.createUser(
+            user['login'],
+            user['email'],
+            user['firstName'],
+            user['lastName'],
+            user['password'],
+        )
+    except HttpError as err:
+        if err.response.json()['message'] != 'That login is already registered.':
+            raise err
+
+
+@pytest.mark.integration
+@pytest.mark.parametrize("user", [zipUser])
+@pytest.mark.run(order=3)
+def test_reset_integration_env(user: dict):
+    client = GirderClient(apiUrl='http://localhost:8010/api/v1')
+    client.authenticate(username=user['login'], password=user['password'])
+    privateFolder = getTestFolder(client)
+    client.delete(f"folder/{privateFolder['_id']}")
+
+
+@pytest.mark.integration
+@pytest.mark.parametrize("dataset", zipUser['data'])
+@pytest.mark.run(order=4)
+def test_upload_zip_data(dataset: dict):
+    user = zipUser
+    client = GirderClient(apiUrl='http://localhost:8010/api/v1')
+    client.authenticate(username=user['login'], password=user['password'])
+
+    dsPath = localDataRoot / str(dataset['path'])
+    privateFolder = getTestFolder(client)
+    newDatasetFolder = client.createFolder(
+        privateFolder['_id'],
+        dataset['name'],
+        metadata={
+            'fps': dataset['fps'],
+            'type': dataset['type'],
+        },
+    )
+    if Path(dsPath).is_file():
+        client.uploadFileToFolder(newDatasetFolder['_id'], str(dsPath))
+    client.post(f'dive_rpc/postprocess/{newDatasetFolder["_id"]}')
+    wait_for_jobs(client, max_wait_timeout=30, expected_status=dataset['job_status'])
+
+    resultFolder = client.getFolder(newDatasetFolder['_id'])
+    # verify sub datasets if they exist
+    if dataset.get('subDatasets', False):
+        folders = list(client.listFolder(newDatasetFolder['_id']))
+        for item in dataset["subDatasets"]:
+            matches = [x for x in folders if x["name"] == item["name"]]
+            if len(matches) > 0:
+                meta = matches[0].get("meta", {})
+                assert meta.get("fps", -1) == item["fps"]
+                assert meta.get("type", "") == item["type"]
+                assert meta.get("annotate", False)
+    elif dataset['job_status'] == JobStatus.SUCCESS:
+        assert resultFolder['meta'].get("annotate", False)
+        assert type(resultFolder['meta'].get("fps")) in [int, float]
+        assert type(resultFolder['meta'].get("type")) == str
+    else:
+        assert resultFolder['meta'].get("annotate", None) is None