diff --git a/README.md b/README.md
index 15258b7..696d1cf 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,41 @@
 # seqBackup
 
 Logic for parsing Illumina headers and folders as well as for archiving reads.
+Also handles Oxford Nanopore (MinKNOW) run folders.
+
+## Backing up a run
+
+Illumina (paired-end, demultiplexed later from the archived `Undetermined` reads):
+
+```
+backup_illumina --forward-reads .../Undetermined_S0_L001_R1_001.fastq.gz \
+  --destination-dir /path/to/archive --sample-sheet .../sample_sheet.csv
+```
+
+Nanopore (single-end, already basecalled by MinKNOW). Point it at the MinKNOW
+run folder (`<date>_<time>_<position>_<flowcell>_<runid>[...]`). Every
+`.fastq.gz` chunk under `fastq_pass/` (across all barcode subdirectories, if
+any) is concatenated into one `<flowcell>.fastq.gz` in the archive -- the same
+convention as Illumina, which archives the undemultiplexed `Undetermined`
+reads and splits later. Demultiplexing is not lost: each pass read's fastq
+header still carries `barcode=barcodeNN`/`barcode_alias=`, which is enough to
+split back out with a header-based script; re-demultiplexing from raw sequence
+(e.g. to change stringency) needs `dorado demux`. The `final_summary_*.txt`,
+`report_*.html`, and the top-level `*.csv` / `*.json` / `*.tsv` / `*.md` run
+reports are copied into the archive alongside a `.md5` manifest.
+
+```
+backup_nanopore --run-dir .../20260401_1506_MN47822_FBE92725_8b1f29fd \
+  --sample-sheet .../CHOPMC-611_NimaGen_04012026.tsv
+```
+
+`--sample-sheet` is required so the run's metadata is always recorded (for a
+transfer run with no metadata, point it at a dummy placeholder file).
+`--destination-dir` defaults to `/mnt/isilon/microbiome/raw_data`. `--min-file-size`
+(default 500MB) is the minimum size of the concatenated fastq.
+
+Both commands take `--allow-check-failures` to archive despite failed validation
+checks (a warning is emitted instead of an error).
 
 ## Dev
 
@@ -23,7 +58,9 @@ git commit ...
 
 ### Adding a new machine type
 
-To add a new machine type, add the new machine code to the `MACHINE_TYPES` map in `seqBackuplib/illumina.py`. In some cases, you may have to add machine specific parsing in `_parse_header` or `_parse_folder`. In `test/test_illumina.py`, we have a mechanism for requiring tests for each supported machine type. Add the new machine type to the `machine_fixtures` map and then create the fixture that it points to in `test/conftest.py`. Follow the pattern laid out by other fixtures and try to make the test data as realistic as possible.
+To add a new Illumina machine type, add the new machine code to the `MACHINE_TYPES` map in `seqBackuplib/illumina.py`. In some cases, you may have to add machine specific parsing in `_parse_header` or `_parse_folder`. In `test/test_illumina.py`, we have a mechanism for requiring tests for each supported machine type. Add the new machine type to the `machine_fixtures` map and then create the fixture that it points to in `test/conftest.py`. Follow the pattern laid out by other fixtures and try to make the test data as realistic as possible.
+
+To add a new Nanopore device, add its position-token prefix to the `ONT_MACHINE_TYPES` map in `seqBackupLib/nanopore.py` (e.g. `MN47822` -> `MN`, `P2I-00513-B` -> `P2I`; see `extract_ont_device_code`). `test/test_nanopore.py` has the same "every machine type must be tested" mechanism: add the device to `ont_machine_fixtures` and create the matching run-folder fixture in `test/conftest.py`.
 
 ### Incorporating new version
 
diff --git a/pyproject.toml b/pyproject.toml
index 16c687a..4457513 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -15,6 +15,7 @@ homepage = "https://github.com/PennChopMicrobiomeProgram"
 
 [project.scripts]
 backup_illumina = "seqBackupLib.backup:main"
+backup_nanopore = "seqBackupLib.backup_nanopore:cli"
 
 [tool.setuptools.packages.find]
 where = ["."]
diff --git a/seqBackupLib/backup_nanopore.py b/seqBackupLib/backup_nanopore.py
new file mode 100644
index 0000000..6794310
--- /dev/null
+++ b/seqBackupLib/backup_nanopore.py
@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import argparse
+import gzip
+import hashlib
+import shutil
+import stat
+import tempfile
+import warnings
+from pathlib import Path
+
+from seqBackupLib.nanopore import NanoporeDir, NanoporeFastq, natural_sort_key
+
+# A real ONT run is always well over this; the check exists to catch a run that
+# was pointed at the wrong folder or copied while still in progress.
+DEFAULT_MIN_FILE_SIZE = 500000000  # 500MB
+
+FASTQ_PASS_DIRNAME = "fastq_pass"
+
+# Where runs are almost always archived.
+DEFAULT_DESTINATION_DIR = Path("/mnt/isilon/microbiome/raw_data")
+
+# Top-level run files worth keeping alongside the reads.  ``*.txt`` is
+# intentionally narrow: we want ``final_summary_*.txt`` but not the (huge)
+# ``sequencing_summary_*.txt``.
+REPORT_GLOBS = (
+    "*.csv",
+    "*.json",
+    "*.tsv",
+    "*.md",
+    "report_*.html",
+    "final_summary_*.txt",
+)
+
+READ_ONLY = stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH
+
+
+def return_md5(fp: Path) -> str:
+    # from https://stackoverflow.com/questions/3431825/generating-an-md5-checksum-of-a-file
+    hash_md5 = hashlib.md5()
+    with open(fp, "rb") as f:
+        for chunk in iter(lambda: f.read(4096), b""):
+            hash_md5.update(chunk)
+    return hash_md5.hexdigest()
+
+
+def find_fastq_chunks(fastq_pass_dir: Path) -> list[Path]:
+    """All fastq.gz chunks under fastq_pass/, in a stable concatenation order.
+
+    A multiplexed run keeps its chunks under ``fastq_pass/<barcode>/``; a
+    non-multiplexed run drops them straight into ``fastq_pass/``. Either way,
+    every chunk is merged into one archived file (matching the Illumina
+    convention of archiving the undemultiplexed reads and splitting later), so
+    sorting is by (containing folder, natural chunk order) purely to make the
+    result reproducible and easy to reason about -- not to group output files.
+    """
+    return sorted(
+        fastq_pass_dir.rglob("*.fastq.gz"),
+        key=lambda p: (p.parent.name, natural_sort_key(p)),
+    )
+
+
+def concatenate_gzips(chunks: list[Path], dest: Path) -> str:
+    """Concatenate gzip members byte-for-byte (a valid multi-member gzip).
+
+    Returns the md5 of the written file, computed in the same pass so a large
+    archive is not read back a second time.
+    """
+    hash_md5 = hashlib.md5()
+    with open(dest, "wb") as out:
+        for chunk in chunks:
+            with open(chunk, "rb") as handle:
+                while data := handle.read(1024 * 1024):
+                    hash_md5.update(data)
+                    out.write(data)
+    return hash_md5.hexdigest()
+
+
+def backup_nanopore(
+    run_dir: Path,
+    dest_dir: Path,
+    sample_sheet: Path,
+    min_file_size: int = DEFAULT_MIN_FILE_SIZE,
+    allow_check_failures: bool = False,
+) -> Path:
+    run_dir = Path(run_dir)
+    dest_dir = Path(dest_dir)
+    sample_sheet = Path(sample_sheet)
+
+    # Parsing the folder name determines the archive location, so this always
+    # hard-fails regardless of --allow-check-failures.
+    nd = NanoporeDir(run_dir.name)
+
+    # Required so the run's metadata is always recorded; a transfer run with no
+    # metadata is expected to point this at a dummy placeholder file.
+    if not sample_sheet.is_file():
+        raise IOError("Sample sheet does not exist", str(sample_sheet))
+
+    fastq_pass = run_dir / FASTQ_PASS_DIRNAME
+    if not fastq_pass.is_dir():
+        raise IOError("fastq_pass directory not found", str(fastq_pass))
+
+    chunks = find_fastq_chunks(fastq_pass)
+    if not chunks:
+        raise IOError("No .fastq.gz files found under fastq_pass", str(fastq_pass))
+
+    write_dir = dest_dir / nd.build_archive_dir()
+    if write_dir.exists():
+        raise FileExistsError(f"Archive directory already exists: {write_dir}")
+
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    staging = Path(
+        tempfile.mkdtemp(dir=dest_dir, prefix=f".{nd.build_archive_dir()}.staging.")
+    )
+    try:
+        flowcell_id = nd.folder_info["flowcell_id"]
+        out_fp = staging / f"{flowcell_id}.fastq.gz"
+
+        digest = concatenate_gzips(chunks, out_fp)
+        file_size = out_fp.stat().st_size
+
+        with gzip.open(out_fp, "rt") as handle:
+            nf = NanoporeFastq(handle, expected_flowcell=flowcell_id)
+        ok, problems = nf.check_fp_vs_content()
+
+        if file_size < min_file_size:
+            message = (
+                f"Concatenated fastq is {file_size} bytes, below the minimum of "
+                f"{min_file_size}. Check the run folder or lower --min-file-size."
+            )
+            if allow_check_failures:
+                warnings.warn(message)
+            else:
+                raise ValueError(message)
+
+        if not ok:
+            message = ("FASTQ header info does not match the run folder", problems)
+            if allow_check_failures:
+                warnings.warn(f"{message[0]}: {message[1]}")
+            else:
+                raise ValueError(*message)
+
+        for pattern in REPORT_GLOBS:
+            for src in sorted(run_dir.glob(pattern)):
+                if src.is_file():
+                    shutil.copyfile(src, staging / src.name)
+
+        # Copied last so the supplied sheet wins over the run's own
+        # sample_sheet_*.csv if they happen to share a name.
+        shutil.copyfile(sample_sheet, staging / sample_sheet.name)
+
+        md5_out_fp = staging / ".".join([nd.build_archive_dir(), "md5"])
+        with open(md5_out_fp, "w") as md5_out:
+            md5_out.write("\t".join([out_fp.name, digest]) + "\n")
+
+        for path in staging.iterdir():
+            if path.is_file():
+                path.chmod(READ_ONLY)
+
+        # All checks passed: publish the staged archive.
+        write_dir.mkdir(parents=True, exist_ok=False)
+        for child in sorted(staging.iterdir()):
+            shutil.move(str(child), str(write_dir / child.name))
+    except BaseException:
+        if write_dir.is_dir():
+            shutil.rmtree(write_dir, ignore_errors=True)
+        raise
+    finally:
+        shutil.rmtree(staging, ignore_errors=True)
+
+    return write_dir
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        description="Concatenate and back up Oxford Nanopore fastq_pass reads"
+    )
+    parser.add_argument(
+        "--run-dir",
+        required=True,
+        type=Path,
+        help="The MinKNOW run folder (contains fastq_pass/ and the run reports).",
+    )
+    parser.add_argument(
+        "--destination-dir",
+        required=False,
+        type=Path,
+        default=DEFAULT_DESTINATION_DIR,
+        help=f"Destination folder to write the archive to (default: {DEFAULT_DESTINATION_DIR}).",
+    )
+    parser.add_argument(
+        "--sample-sheet",
+        required=True,
+        type=Path,
+        help="The sample sheet associated with the run.",
+    )
+    parser.add_argument(
+        "--min-file-size",
+        required=False,
+        type=int,
+        default=DEFAULT_MIN_FILE_SIZE,
+        help="Minimum size (bytes) of the concatenated fastq file.",
+    )
+    parser.add_argument(
+        "--allow-check-failures",
+        action="store_true",
+        help="Continue archiving even if validation checks fail",
+    )
+    args = parser.parse_args(argv)
+    return backup_nanopore(
+        args.run_dir,
+        args.destination_dir,
+        args.sample_sheet,
+        args.min_file_size,
+        args.allow_check_failures,
+    )
+
+
+def cli(argv=None):
+    """Console-script entry point (see pyproject.toml's [project.scripts]).
+
+    main() returns the archive Path -- library callers (e.g. auto_bfx's
+    archive task) depend on that. But the installed console-script wraps its
+    entry point as sys.exit(entry_point()), and sys.exit() treats any
+    non-None, non-int argument as an error: it gets printed to stderr and the
+    process exits 1. Routing main()'s Path return straight through sys.exit()
+    made every successful `backup_nanopore` invocation report as a failure.
+    This wrapper prints the path instead and returns a real exit code.
+    """
+    write_dir = main(argv)
+    print(write_dir)
+    return 0
diff --git a/seqBackupLib/nanopore.py b/seqBackupLib/nanopore.py
new file mode 100644
index 0000000..3fa6543
--- /dev/null
+++ b/seqBackupLib/nanopore.py
@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import re
+from io import TextIOWrapper
+from pathlib import Path
+
+# Oxford Nanopore device codes, keyed by the alphabetic prefix of the position
+# token in a MinKNOW run folder name (e.g. ``MN47822`` -> ``MN``,
+# ``P2I-00513-B`` -> ``P2I``).  Extend this map when a new device shows up; see
+# the "Adding a new machine type" section of the README.
+ONT_MACHINE_TYPES = {
+    "MN": "ONT-MN",  # MinION Mk1B / Mk1C
+    "P2I": "ONT-P2I",  # PromethION 2 Integrated
+}
+
+_DIGITS = "0123456789"
+
+
+def extract_ont_device_code(position: str) -> str:
+    """Return the device code embedded in a MinKNOW position token.
+
+    ``MN47822`` -> ``MN`` (trailing serial number stripped)
+    ``P2I-00513-B`` -> ``P2I`` (only the first hyphen-delimited segment is used)
+    """
+    return position.split("-", 1)[0].rstrip(_DIGITS)
+
+
+def natural_sort_key(path: Path) -> list:
+    """Sort key that orders ``reads_2.fastq.gz`` before ``reads_10.fastq.gz``."""
+    return [
+        int(token) if token.isdigit() else token.lower()
+        for token in re.split(r"(\d+)", path.name)
+    ]
+
+
+class NanoporeDir:
+    """Parses an Oxford Nanopore (MinKNOW) run folder name.
+
+    Expected shape::
+
+        <YYYYMMDD>_<HHMM>_<position>_<flow_cell_id>_<short_run_id>[_<run_alias>]
+
+    e.g. ``20260401_1506_MN47822_FBE92725_8b1f29fd`` or
+    ``20260408_1652_P2I-00513-B_PBK70557_2fe9fcef_Promethion_Training``.
+    """
+
+    def __init__(self, run_name: str):
+        self.run_name = run_name
+        self.folder_info = self._parse_folder()
+
+    def _parse_folder(self) -> dict[str, str]:
+        parts = self.run_name.split("_")
+        if len(parts) < 5:
+            raise ValueError(f"Not a nanopore run folder name: {self.run_name}")
+
+        date, time_, position, flowcell_id, short_run_id = parts[:5]
+        run_alias = "_".join(parts[5:])
+
+        if not (len(date) == 8 and date.isdigit()):
+            raise ValueError(f"Invalid date in run name: {date}")
+        formatted_date = f"{date[0:4]}-{date[4:6]}-{date[6:8]}"
+
+        if not (len(time_) == 4 and time_.isdigit()):
+            raise ValueError(f"Invalid time in run name: {time_}")
+
+        device_code = extract_ont_device_code(position)
+        if device_code not in ONT_MACHINE_TYPES:
+            raise ValueError(f"Unknown nanopore device in run name: {position}")
+        self.machine_type = ONT_MACHINE_TYPES[device_code]
+
+        return {
+            "date": formatted_date,
+            "time": time_,
+            "position": position,
+            "device_code": device_code,
+            "flowcell_id": flowcell_id,
+            "short_run_id": short_run_id,
+            "run_alias": run_alias,
+        }
+
+    def build_archive_dir(self) -> str:
+        # Nanopore has no lane concept; archive under the full run folder name.
+        return self.run_name
+
+
+class NanoporeFastq:
+    """Parses the first header line of an ONT fastq to sanity check a run.
+
+    ONT/dorado headers are ``@<read_id> key=value key=value ...`` where the
+    interesting keys are ``flow_cell_id`` and (for multiplexed runs)
+    ``barcode``.  Older basecallers may omit these; missing keys are treated as
+    "nothing to check" rather than a failure.
+    """
+
+    def __init__(
+        self,
+        f: TextIOWrapper,
+        expected_flowcell: str | None = None,
+        expected_barcode: str | None = None,
+    ):
+        self.file = f
+        self.expected_flowcell = expected_flowcell
+        self.expected_barcode = expected_barcode
+        self.info = self._parse_header()
+
+    def _parse_header(self) -> dict[str, str]:
+        try:
+            line = next(self.file).strip()
+        except StopIteration:
+            raise ValueError("FASTQ file is empty")
+        if not line.startswith("@"):
+            raise ValueError("Not a FASTQ header line")
+
+        tokens = line[1:].split()
+        info = {"read_id": tokens[0] if tokens else ""}
+        for token in tokens[1:]:
+            if "=" in token:
+                key, value = token.split("=", 1)
+                info[key] = value
+        return info
+
+    def check_fp_vs_content(self) -> tuple[bool, dict[str, tuple[str, str]]]:
+        problems: dict[str, tuple[str, str]] = {}
+
+        flowcell = self.info.get("flow_cell_id")
+        if self.expected_flowcell and flowcell and flowcell != self.expected_flowcell:
+            problems["flow_cell_id"] = (flowcell, self.expected_flowcell)
+
+        barcode = self.info.get("barcode")
+        if self.expected_barcode and barcode and barcode != self.expected_barcode:
+            problems["barcode"] = (barcode, self.expected_barcode)
+
+        return (not problems, problems)
diff --git a/test/conftest.py b/test/conftest.py
index 914e506..58765cf 100644
--- a/test/conftest.py
+++ b/test/conftest.py
@@ -1,8 +1,125 @@
+from __future__ import annotations
+
 import gzip
 import pytest
 from pathlib import Path
 
 
+def _write_ont_fastq(fp: Path, headers: list[str]) -> None:
+    sequence = "ACGTACGTAC"
+    quality = "IIIIIIIIII"
+    with gzip.open(fp, "wt") as handle:
+        for header in headers:
+            handle.write(f"@{header}\n{sequence}\n+\n{quality}\n")
+
+
+def setup_nanopore_dir(
+    base: Path,
+    run_name: str,
+    flowcell_id: str,
+    barcodes: list[str],
+    n_chunks: int = 3,
+) -> Path:
+    """Build a realistic MinKNOW run folder.
+
+    ``barcodes`` is the list of ``fastq_pass`` subdirectory names to create; pass
+    an empty list for a non-multiplexed run (chunks land directly in
+    ``fastq_pass/``).
+    """
+    run_dir = base / run_name
+    fastq_pass = run_dir / "fastq_pass"
+    fastq_pass.mkdir(parents=True, exist_ok=True)
+
+    def _chunks_into(target: Path, label: str, barcode: str | None) -> None:
+        for i in range(n_chunks):
+            fields = [
+                f"{label}-read-{i}-0000-0000-000000000000",
+                "runid=8b1f29fd-6233-456a-9c6c-d8d72cecc734",
+                "ch=5",
+                "start_time=2026-04-01T15:14:56.068015-04:00",
+                f"flow_cell_id={flowcell_id}",
+                "protocol_group_id=CHOPMC-611_NimaGen_04012026",
+                "sample_id=",
+            ]
+            if barcode is not None:
+                fields.append(f"barcode={barcode}")
+                fields.append(f"barcode_alias={barcode}")
+            fields.append(
+                "basecall_model_version_id=dna_r10.4.1_e8.2_400bps_hac@v4.3.0"
+            )
+            # chunk indices deliberately out of lexical order (_10 sorts after _2)
+            _write_ont_fastq(
+                target
+                / f"{flowcell_id}_pass_{label}_8b1f29fd_117e08fc_{i * 5}.fastq.gz",
+                [" ".join(fields)],
+            )
+
+    if barcodes:
+        for barcode in barcodes:
+            sub = fastq_pass / barcode
+            sub.mkdir(parents=True, exist_ok=True)
+            _chunks_into(sub, barcode, barcode)
+    else:
+        _chunks_into(fastq_pass, "all", None)
+
+    # Top-level run reports/metadata that should be archived.
+    (run_dir / f"final_summary_{flowcell_id}_x.txt").write_text(
+        f"instrument=MN47822\nflow_cell_id={flowcell_id}\n"
+    )
+    (run_dir / f"report_{flowcell_id}_x.html").write_text("<html>ONT report</html>")
+    (run_dir / f"report_{flowcell_id}_x.json").write_text('{"run": "ok"}')
+    (run_dir / f"report_{flowcell_id}_x.md").write_text("# ONT report\n")
+    (run_dir / f"sample_sheet_{flowcell_id}_x.csv").write_text(
+        f"flow_cell_id\n{flowcell_id}\n"
+    )
+    (run_dir / f"throughput_{flowcell_id}_x.csv").write_text("minute,reads\n0,0\n")
+    (run_dir / f"barcode_alignment_{flowcell_id}_x.tsv").write_text("barcode\talias\n")
+
+    # Noise that must NOT be archived.
+    (run_dir / ".DS_Store").write_text("junk")
+    (run_dir / ".Rhistory").write_text("")
+    (run_dir / f"sequencing_summary_{flowcell_id}_x.txt").write_text("huge summary\n")
+
+    return run_dir
+
+
+@pytest.fixture
+def minion_dir(tmp_path) -> Path:
+    return setup_nanopore_dir(
+        tmp_path,
+        "20260401_1506_MN47822_FBE92725_8b1f29fd",
+        "FBE92725",
+        ["barcode01", "barcode02", "unclassified"],
+    )
+
+
+@pytest.fixture
+def p2i_dir(tmp_path) -> Path:
+    return setup_nanopore_dir(
+        tmp_path,
+        "20260408_1652_P2I-00513-B_PBK70557_2fe9fcef_Promethion_Training",
+        "PBK70557",
+        ["barcode01", "barcode02", "unclassified"],
+    )
+
+
+@pytest.fixture
+def non_barcoded_nanopore_dir(tmp_path) -> Path:
+    return setup_nanopore_dir(
+        tmp_path,
+        "20260401_1506_MN47822_FBE92725_8b1f29fd",
+        "FBE92725",
+        [],
+    )
+
+
+@pytest.fixture
+def nanopore_sample_sheet(tmp_path) -> Path:
+    fp = tmp_path / "CHOPMC-611_NimaGen_04012026.tsv"
+    fp.write_text("barcode\tsample_id\nbarcode01\tS1\nbarcode02\tS2\n")
+    return fp
+
+
 def setup_illumina_dir(fp: Path, r1: str, r1_lines: list[str]) -> Path:
     fp.mkdir(parents=True, exist_ok=True)
 
diff --git a/test/test_backup_nanopore.py b/test/test_backup_nanopore.py
new file mode 100644
index 0000000..52d9bcd
--- /dev/null
+++ b/test/test_backup_nanopore.py
@@ -0,0 +1,257 @@
+import gzip
+import os
+import shutil
+import stat
+from pathlib import Path
+
+import pytest
+
+import seqBackupLib.backup_nanopore as bn
+from seqBackupLib.backup_nanopore import (
+    DEFAULT_DESTINATION_DIR,
+    backup_nanopore,
+    cli,
+    find_fastq_chunks,
+    main,
+    return_md5,
+)
+
+
+def _count_records(fp) -> int:
+    with gzip.open(fp, "rt") as handle:
+        return sum(1 for _ in handle) // 4
+
+
+def test_find_fastq_chunks_barcoded(minion_dir):
+    chunks = find_fastq_chunks(minion_dir / "fastq_pass")
+    # every chunk across every barcode folder, grouped by folder then natural
+    # (numeric) chunk order -- not lexical (_10 before _5)
+    assert [p.name for p in chunks] == [
+        "FBE92725_pass_barcode01_8b1f29fd_117e08fc_0.fastq.gz",
+        "FBE92725_pass_barcode01_8b1f29fd_117e08fc_5.fastq.gz",
+        "FBE92725_pass_barcode01_8b1f29fd_117e08fc_10.fastq.gz",
+        "FBE92725_pass_barcode02_8b1f29fd_117e08fc_0.fastq.gz",
+        "FBE92725_pass_barcode02_8b1f29fd_117e08fc_5.fastq.gz",
+        "FBE92725_pass_barcode02_8b1f29fd_117e08fc_10.fastq.gz",
+        "FBE92725_pass_unclassified_8b1f29fd_117e08fc_0.fastq.gz",
+        "FBE92725_pass_unclassified_8b1f29fd_117e08fc_5.fastq.gz",
+        "FBE92725_pass_unclassified_8b1f29fd_117e08fc_10.fastq.gz",
+    ]
+
+
+def test_find_fastq_chunks_non_barcoded(non_barcoded_nanopore_dir):
+    chunks = find_fastq_chunks(non_barcoded_nanopore_dir / "fastq_pass")
+    assert len(chunks) == 3
+
+
+def test_backup_nanopore_archives_reads_and_reports(
+    tmp_path, minion_dir, nanopore_sample_sheet
+):
+    dest = tmp_path / "archive"
+
+    out_dir = backup_nanopore(minion_dir, dest, nanopore_sample_sheet, min_file_size=1)
+
+    assert out_dir == dest / minion_dir.name
+    assert out_dir.is_dir()
+
+    # every chunk from every barcode folder is merged into one file, matching
+    # how Illumina archives the undemultiplexed reads
+    fq = out_dir / "FBE92725.fastq.gz"
+    assert fq.is_file()
+    assert _count_records(fq) == 9  # 3 barcode dirs x 3 single-read chunks
+
+    # reports kept
+    assert (out_dir / "final_summary_FBE92725_x.txt").is_file()
+    assert (out_dir / "report_FBE92725_x.html").is_file()
+    assert (out_dir / "report_FBE92725_x.json").is_file()
+    assert (out_dir / "report_FBE92725_x.md").is_file()
+    assert (out_dir / "sample_sheet_FBE92725_x.csv").is_file()
+    assert (out_dir / "throughput_FBE92725_x.csv").is_file()
+    assert (out_dir / "barcode_alignment_FBE92725_x.tsv").is_file()
+
+    # the supplied (official) sample sheet is archived
+    assert (out_dir / nanopore_sample_sheet.name).is_file()
+
+    # noise left behind
+    assert not (out_dir / ".DS_Store").exists()
+    assert not (out_dir / ".Rhistory").exists()
+    assert not (out_dir / "sequencing_summary_FBE92725_x.txt").exists()
+
+    # md5 manifest covers the concatenated fastq
+    md5_fp = out_dir / f"{minion_dir.name}.md5"
+    assert md5_fp.is_file()
+    entries = dict(line.split("\t") for line in md5_fp.read_text().splitlines() if line)
+    assert set(entries) == {"FBE92725.fastq.gz"}
+    assert entries["FBE92725.fastq.gz"].strip() == return_md5(fq)
+
+    # archived fastq is read-only
+    assert not (stat.S_IMODE(os.stat(fq).st_mode) & stat.S_IWUSR)
+
+
+def test_backup_nanopore_non_barcoded(
+    tmp_path, non_barcoded_nanopore_dir, nanopore_sample_sheet
+):
+    dest = tmp_path / "archive"
+    out_dir = backup_nanopore(
+        non_barcoded_nanopore_dir, dest, nanopore_sample_sheet, min_file_size=1
+    )
+    fq = out_dir / "FBE92725.fastq.gz"
+    assert fq.is_file()
+    assert _count_records(fq) == 3
+
+
+def test_backup_nanopore_missing_sample_sheet(tmp_path, minion_dir):
+    with pytest.raises(IOError, match="Sample sheet does not exist"):
+        backup_nanopore(
+            minion_dir,
+            tmp_path / "archive",
+            tmp_path / "nope.csv",
+            min_file_size=1,
+        )
+    # bailed out before creating anything
+    assert not (tmp_path / "archive").exists()
+
+
+def test_backup_nanopore_dummy_sample_sheet_ok(tmp_path, minion_dir):
+    # transfer runs with no metadata use a placeholder file
+    dummy = tmp_path / "dummy.tsv"
+    dummy.write_text("no metadata; transfer run\n")
+
+    out_dir = backup_nanopore(minion_dir, tmp_path / "archive", dummy, min_file_size=1)
+    assert (out_dir / "dummy.tsv").is_file()
+
+
+def test_backup_nanopore_refuses_existing_archive(
+    tmp_path, minion_dir, nanopore_sample_sheet
+):
+    dest = tmp_path / "archive"
+    backup_nanopore(minion_dir, dest, nanopore_sample_sheet, min_file_size=1)
+    with pytest.raises(FileExistsError):
+        backup_nanopore(minion_dir, dest, nanopore_sample_sheet, min_file_size=1)
+
+
+def test_backup_nanopore_size_check(tmp_path, minion_dir, nanopore_sample_sheet):
+    dest = tmp_path / "archive"
+
+    with pytest.raises(ValueError, match="below the minimum"):
+        backup_nanopore(minion_dir, dest, nanopore_sample_sheet, min_file_size=10**12)
+
+    # nothing left behind after the failure
+    assert not (dest / minion_dir.name).exists()
+    assert list(dest.iterdir()) == []
+
+    with pytest.warns(UserWarning, match="below the minimum"):
+        out_dir = backup_nanopore(
+            minion_dir,
+            dest,
+            nanopore_sample_sheet,
+            min_file_size=10**12,
+            allow_check_failures=True,
+        )
+    assert out_dir.is_dir()
+
+
+def test_backup_nanopore_header_mismatch(tmp_path, minion_dir, nanopore_sample_sheet):
+    # barcode01 sorts first, so corrupting it corrupts the merged file's first
+    # (representative) header
+    bc = minion_dir / "fastq_pass" / "barcode01"
+    for chunk in bc.glob("*.fastq.gz"):
+        with gzip.open(chunk, "wt") as handle:
+            handle.write("@readx flow_cell_id=WRONG\nACGT\n+\nIIII\n")
+
+    dest = tmp_path / "archive"
+    with pytest.raises(ValueError, match="header info does not match"):
+        backup_nanopore(minion_dir, dest, nanopore_sample_sheet, min_file_size=1)
+
+    with pytest.warns(UserWarning, match="header info does not match"):
+        backup_nanopore(
+            minion_dir,
+            dest,
+            nanopore_sample_sheet,
+            min_file_size=1,
+            allow_check_failures=True,
+        )
+
+
+def test_backup_nanopore_missing_fastq_pass(
+    tmp_path, minion_dir, nanopore_sample_sheet
+):
+    shutil.rmtree(minion_dir / "fastq_pass")
+    with pytest.raises(IOError):
+        backup_nanopore(
+            minion_dir, tmp_path / "archive", nanopore_sample_sheet, min_file_size=1
+        )
+
+
+def test_main_returns_archive_path(tmp_path, p2i_dir, nanopore_sample_sheet):
+    # main() is also called directly as a library function (e.g. by
+    # auto_bfx's archive task), which depends on getting the archive Path
+    # back -- so main() itself must keep returning it. See test_cli_* below
+    # for the console-script entry point, which wraps main() instead of
+    # replacing it.
+    dest = tmp_path / "archive"
+    out_dir = main(
+        [
+            "--run-dir",
+            str(p2i_dir),
+            "--destination-dir",
+            str(dest),
+            "--sample-sheet",
+            str(nanopore_sample_sheet),
+            "--min-file-size",
+            "1",
+        ]
+    )
+    assert out_dir == dest / p2i_dir.name
+    assert out_dir.is_dir()
+    assert (out_dir / "PBK70557.fastq.gz").is_file()
+    assert (out_dir / nanopore_sample_sheet.name).is_file()
+
+
+def test_cli_prints_archive_path_and_returns_zero(
+    capsys, tmp_path, p2i_dir, nanopore_sample_sheet
+):
+    # cli() is what [project.scripts] points backup_nanopore at. The
+    # installed console-script wraps it as sys.exit(cli()), and sys.exit()
+    # treats any non-None, non-int argument as an error -- printed to
+    # stderr, exit code 1 -- so cli() must return 0/None rather than the
+    # Path main() returns, or every successful run would report as a
+    # failure.
+    dest = tmp_path / "archive"
+    out_dir = dest / p2i_dir.name
+    result = cli(
+        [
+            "--run-dir",
+            str(p2i_dir),
+            "--destination-dir",
+            str(dest),
+            "--sample-sheet",
+            str(nanopore_sample_sheet),
+            "--min-file-size",
+            "1",
+        ]
+    )
+    assert result == 0
+    assert capsys.readouterr().out.strip() == str(out_dir)
+    assert out_dir.is_dir()
+    assert (out_dir / "PBK70557.fastq.gz").is_file()
+    assert (out_dir / nanopore_sample_sheet.name).is_file()
+
+
+def test_sample_sheet_is_required(tmp_path, minion_dir):
+    with pytest.raises(SystemExit):
+        main(["--run-dir", str(minion_dir), "--destination-dir", str(tmp_path)])
+
+
+def test_destination_dir_defaults_to_raw_data(monkeypatch, tmp_path, minion_dir):
+    assert DEFAULT_DESTINATION_DIR == Path("/mnt/isilon/microbiome/raw_data")
+
+    seen = {}
+
+    def fake_backup(run_dir, dest_dir, *args, **kwargs):
+        seen["dest"] = dest_dir
+        return tmp_path
+
+    monkeypatch.setattr(bn, "backup_nanopore", fake_backup)
+    main(["--run-dir", str(minion_dir), "--sample-sheet", str(tmp_path / "s.csv")])
+    assert seen["dest"] == DEFAULT_DESTINATION_DIR
diff --git a/test/test_nanopore.py b/test/test_nanopore.py
new file mode 100644
index 0000000..16dfb65
--- /dev/null
+++ b/test/test_nanopore.py
@@ -0,0 +1,127 @@
+import io
+from pathlib import Path
+
+import pytest
+
+from seqBackupLib.nanopore import (
+    ONT_MACHINE_TYPES,
+    NanoporeDir,
+    NanoporeFastq,
+    extract_ont_device_code,
+    natural_sort_key,
+)
+
+# Every supported ONT machine type must have a fixture exercising it, mirroring
+# the mechanism in test_illumina.py.
+ont_machine_fixtures = {
+    "ONT-MN": "minion_dir",
+    "ONT-P2I": "p2i_dir",
+}
+
+
+def test_all_ont_machine_types_are_tested():
+    missing = set(ONT_MACHINE_TYPES.values()) - set(ont_machine_fixtures)
+    assert not missing, f"Missing nanopore fixtures for machine types: {missing}"
+
+
+@pytest.mark.parametrize("machine_type", ont_machine_fixtures.keys())
+def test_nanopore_dir(machine_type, request):
+    run_dir = request.getfixturevalue(ont_machine_fixtures[machine_type])
+
+    nd = NanoporeDir(run_dir.name)
+
+    assert nd.machine_type == machine_type
+    assert nd.folder_info["flowcell_id"] in run_dir.name
+    assert nd.build_archive_dir() == run_dir.name
+
+
+def test_extract_ont_device_code():
+    assert extract_ont_device_code("MN47822") == "MN"
+    assert extract_ont_device_code("P2I-00513-B") == "P2I"
+    assert extract_ont_device_code("GXB01234-X1") == "GXB"
+
+
+def test_nanopore_dir_parses_minion():
+    nd = NanoporeDir("20260401_1506_MN47822_FBE92725_8b1f29fd")
+    assert nd.folder_info == {
+        "date": "2026-04-01",
+        "time": "1506",
+        "position": "MN47822",
+        "device_code": "MN",
+        "flowcell_id": "FBE92725",
+        "short_run_id": "8b1f29fd",
+        "run_alias": "",
+    }
+    assert nd.machine_type == "ONT-MN"
+
+
+def test_nanopore_dir_parses_p2i_with_alias():
+    nd = NanoporeDir("20260408_1652_P2I-00513-B_PBK70557_2fe9fcef_Promethion_Training")
+    assert nd.folder_info["position"] == "P2I-00513-B"
+    assert nd.folder_info["device_code"] == "P2I"
+    assert nd.folder_info["flowcell_id"] == "PBK70557"
+    assert nd.folder_info["run_alias"] == "Promethion_Training"
+    assert nd.machine_type == "ONT-P2I"
+
+
+@pytest.mark.parametrize(
+    "bad_name",
+    [
+        "not_a_run",
+        "20260401_1506_XX12345_FBE92725_8b1f29fd",  # unknown device
+        "2026041_1506_MN47822_FBE92725_8b1f29fd",  # bad date
+        "20260401_156_MN47822_FBE92725_8b1f29fd",  # bad time
+    ],
+)
+def test_nanopore_dir_rejects_bad_names(bad_name):
+    with pytest.raises(ValueError):
+        NanoporeDir(bad_name)
+
+
+def test_natural_sort_key_orders_numerically():
+    names = ["r_10.fastq.gz", "r_2.fastq.gz", "r_1.fastq.gz"]
+    ordered = sorted((Path(n) for n in names), key=natural_sort_key)
+    assert [p.name for p in ordered] == [
+        "r_1.fastq.gz",
+        "r_2.fastq.gz",
+        "r_10.fastq.gz",
+    ]
+
+
+def _handle(header: str) -> io.StringIO:
+    return io.StringIO(f"@{header}\nACGT\n+\nIIII\n")
+
+
+def test_nanopore_fastq_header_parsing_and_checks():
+    header = (
+        "0a1b2c3d-1111 runid=abc read=5 ch=9 flow_cell_id=FBE92725 barcode=barcode01"
+    )
+    nf = NanoporeFastq(
+        _handle(header), expected_flowcell="FBE92725", expected_barcode="barcode01"
+    )
+    assert nf.info["read_id"] == "0a1b2c3d-1111"
+    assert nf.info["flow_cell_id"] == "FBE92725"
+    ok, problems = nf.check_fp_vs_content()
+    assert ok and problems == {}
+
+
+def test_nanopore_fastq_detects_mismatch():
+    header = "readx runid=abc flow_cell_id=WRONG barcode=barcode02"
+    nf = NanoporeFastq(
+        _handle(header), expected_flowcell="FBE92725", expected_barcode="barcode01"
+    )
+    ok, problems = nf.check_fp_vs_content()
+    assert not ok
+    assert problems["flow_cell_id"] == ("WRONG", "FBE92725")
+    assert problems["barcode"] == ("barcode02", "barcode01")
+
+
+def test_nanopore_fastq_tolerates_missing_keys():
+    nf = NanoporeFastq(_handle("readx"), expected_flowcell="FBE92725")
+    ok, problems = nf.check_fp_vs_content()
+    assert ok and problems == {}
+
+
+def test_nanopore_fastq_rejects_non_header():
+    with pytest.raises(ValueError):
+        NanoporeFastq(io.StringIO("ACGT\n"))