diff --git a/echopype/convert/api.py b/echopype/convert/api.py
index bb94e726b..e017df57f 100644
--- a/echopype/convert/api.py
+++ b/echopype/convert/api.py
@@ -2,11 +2,12 @@
 from typing import TYPE_CHECKING, Dict, List, Literal, Optional, Tuple, Union
 
 import fsspec
-from xarray import DataTree
+from xarray import Dataset, DataTree
 
 # fmt: off
 # black and isort have conflicting ideas about how this should be formatted
 from ..core import SONAR_MODELS
+from .set_groups_bi500 import SetGroupsBI500
 
 if TYPE_CHECKING:
     from ..core import EngineHint, PathHint, SonarModelsHint
@@ -264,7 +265,8 @@ def _check_file(
     Parameters
     ----------
     raw_file : str
-        path to raw data file
+        path to raw data file, or for BI500, the directory containing
+        the associated BI500 file set
     sonar_model : str
         model of the sonar instrument
     xml_path : str
@@ -279,7 +281,8 @@ def _check_file(
     Returns
     -------
     raw_file : str
-        path to existing raw data file
+        path to raw data file, or for BI500, the directory containing
+        the associated BI500 file set
     xml : str
         path to existing xml file
         empty string if no xml file is required for the specified model
@@ -354,16 +357,20 @@ def open_raw(
     use_swap: Union[bool, Literal["auto"]] = False,
     max_chunk_size: str = "100MB",
     channels: Optional[List[str]] = None,
-) -> EchoData:
-    """Create an EchoData object containing parsed data from a single raw data file.
+) -> Union[EchoData, Tuple[EchoData, Dataset]]:
+    """Create an EchoData object containing parsed data from a raw data source.
 
     The EchoData object can be used for adding metadata and ancillary data
     as well as to serialize the parsed data to zarr or netcdf.
 
+    For BI500, this function returns ``(echodata, ds_cal)``, where ``ds_cal``
+    contains the calibrated products generated by the BI500 system.
+
     Parameters
     ----------
     raw_file : str
-        path to raw data file
+        path to raw data file, or for BI500, the directory containing
+        the associated BI500 file set
     sonar_model : str
         model of the sonar instrument
 
@@ -375,6 +382,7 @@ def open_raw(
         - ``AZFP6``: ASL Environmental Sciences AZFP echosounder (ULS6)
         - ``AD2CP``: Nortek Signature series ADCP
           (tested with Signature 500 and Signature 1000)
+        - ``BI500``: Bergen Integrator BI500 data
 
     xml_path : str
         path to XML config file used by AZFP (ULS5 only)
@@ -392,7 +400,7 @@ def open_raw(
         When set to ``True`` (or when set to "auto" and large memory footprint is needed,
         this function will create a temporary zarr store at the operating system's
         temporary directory.
-    max_mb : int
+    max_chunk_size : str, default "100MB"
         The maximum data chunk size in Megabytes (MB), when offloading
         variables with a large memory footprint to a temporary zarr store
     channels : list of str, optional
@@ -404,6 +412,11 @@ def open_raw(
     Returns
     -------
     EchoData object
+        For all sonar models except BI500.
+    tuple of EchoData and xarray.Dataset
+        For BI500, returns ``(echodata, ds_cal)``. ``ds_cal`` contains
+        calibrated BI500 products including ``Sv``, ``Sv_bottom``, ``depth``,
+        ``depth_bottom``, and single-target variables.
 
     Raises
     ------
@@ -519,6 +532,15 @@ def open_raw(
             sonar_model=sonar_model,
             date_created=parser.config_datagram["timestamp"],
         )
+    elif sonar_model == "BI500":
+        date_created = SetGroupsBI500._build_ping_time(
+            [parser.parameters["start_date"][0]],
+            [parser.parameters["start_time"][0]],
+        )[0]
+        tree_dict["/"] = setgrouper.set_toplevel(
+            sonar_model=sonar_model,
+            date_created=date_created,
+        )
     else:
         tree_dict["/"] = setgrouper.set_toplevel(
             sonar_model=sonar_model, date_created=parser.ping_time[0]
@@ -564,4 +586,10 @@ def open_raw(
     echodata._set_tree(tree)
     echodata._load_tree()
 
+    # BI500 values are already calibrated by the EK500/BI500 system.
+    # Return these products separately from the EchoData metadata object.
+    if sonar_model == "BI500":
+        ds_cal = setgrouper.set_calibrated()
+        return echodata, ds_cal
+
     return echodata
diff --git a/echopype/convert/parse_bi500.py b/echopype/convert/parse_bi500.py
new file mode 100644
index 000000000..7910b1e63
--- /dev/null
+++ b/echopype/convert/parse_bi500.py
@@ -0,0 +1,334 @@
+import re
+from collections import defaultdict
+from struct import unpack
+
+import fsspec
+import numpy as np
+
+from ..utils.log import _init_logger
+from ..utils.misc import camelcase2snakecase
+from .parse_base import ParseBase
+
+logger = _init_logger(__name__)
+
+FILENAME_DATETIME_BI500 = (
+    "?(?<prefix>.*)?-?F(?P<frequency>\\w+)?-?T(?P<transducer>\\w+)?"
+    "-?D(?P<date>\\w+)?-?T(?P<time>\\w+)"
+)
+
+BI500_FILENAME_PATTERN = re.compile(
+    r"^(?P<prefix>.+)"
+    r"-F(?P<frequency>\d+)"
+    r"-T(?P<transducer>\d+)"
+    r"-D(?P<date>\d{8})"
+    r"-T(?P<time>\d{6})"
+    r"(?P<file_type>-(?:Data|Info|Ping|Vlog|Snap|Work))$"
+)
+
+FILE_TYPES = ["-Data", "-Info", "-Ping", "-Vlog", "-Snap", "-Work"]
+
+REQUIRED_FILES = ["-Data", "-Info", "-Ping"]
+
+# Common BI500 Ping and Vlog parameters for unpacking
+PV_FILE_FORMAT = ">llfffflffllffllll"
+
+PV_FILE_SIZE = 68
+
+PV_FIELDS = (
+    "Date",
+    "Time",
+    "Distance",
+    "Latitude",
+    "Longitude",
+    "BottomDepth",
+    "EchogramType",
+    "PelagicUpper",
+    "PelagicLower",
+    "PelagicCount",
+    "PelagicOffset",
+    "BottomUpper",
+    "BottomLower",
+    "BottomCount",
+    "BottomOffset",
+    "EchotraceCount",
+    "EchotraceOffset",
+)
+
+
+class ParseBI500(ParseBase):
+    """Class for converting data from Bergen Integrator (BI500) software."""
+
+    def __init__(
+        self,
+        file,
+        storage_options={},
+        sonar_model="BI500",
+        file_meta=None,
+        bot_file="",
+        idx_file="",
+        **kwargs,
+    ):
+        super().__init__(file, storage_options, sonar_model)
+
+        self.timestamp_pattern = FILENAME_DATETIME_BI500
+        self.file_types = FILE_TYPES
+
+        # BI500 stores each transceiver/channel in its own companion-file set.
+        # file_set_map groups those sets for a single acquisition.
+        self.file_set_map = {}
+        self.channel_data = {}
+        self.acquisition_key = None
+
+        # Keep the original single-channel attributes as aliases to the first
+        # parsed channel. This preserves the existing BI500 code path/API while
+        # allowing SetGroupsBI500 to iterate over all parsed channels.
+        self.file_type_map = defaultdict(None)
+        self.parameters = defaultdict(list)
+        self.ping_data = defaultdict(list)
+        self.vlog_data = defaultdict(list)
+        self.index_counts = defaultdict(list)
+        self.unpacked_data = defaultdict(list)
+
+        self.fsmap = self._validate_folder_path(file)
+        self.sonar_type = "BI500"
+
+    def _validate_folder_path(self, folder_path):
+        """Validate a folder containing one BI500 acquisition."""
+        fsmap = fsspec.get_mapper(folder_path, **self.storage_options)
+        try:
+            all_files = fsmap.fs.ls(folder_path)
+        except NotADirectoryError:
+            raise ValueError(
+                "Expecting a folder containing at least '-Data', '-Info' and '-Ping' files, "
+                f"but got {folder_path}"
+            )
+
+        self._group_file_sets(all_files)
+        return fsmap
+
+    def _group_file_sets(self, all_files):
+        """Group companion files by BI500 frequency/transceiver file set."""
+        logger.info("Found the following files in the folder:")
+
+        file_set_map = {}
+        acquisition_keys = set()
+
+        for file in all_files:
+            file_name = file if isinstance(file, str) else file.get("name")
+            basename = file_name.replace("\\", "/").rsplit("/", 1)[-1]
+
+            match = BI500_FILENAME_PATTERN.match(basename)
+            if match is None:
+                continue
+
+            info = match.groupdict()
+            acquisition_key = (info["prefix"], info["date"], info["time"])
+            file_set_key = (info["frequency"], info["transducer"])
+
+            acquisition_keys.add(acquisition_key)
+            file_set_map.setdefault(file_set_key, {})
+            file_set_map[file_set_key][info["file_type"]] = file_name
+
+            logger.info(f"Found file: {file_name}")
+
+        if not file_set_map:
+            raise ValueError(
+                "Expecting a folder containing at least '-Data', '-Info' and '-Ping' files, "
+                "but no BI500 file set was found."
+            )
+
+        if len(acquisition_keys) != 1:
+            raise ValueError(
+                "BI500 open_raw expects files from a single acquisition, "
+                f"but found {len(acquisition_keys)} acquisition groups."
+            )
+
+        for file_set_key, file_type_map in file_set_map.items():
+            missing = [file_type for file_type in REQUIRED_FILES if file_type not in file_type_map]
+            if missing:
+                raise ValueError(
+                    f"BI500 file set {file_set_key} is missing required files: {missing}"
+                )
+
+        self.acquisition_key = next(iter(acquisition_keys))
+        self.file_set_map = file_set_map
+
+    def load_BI500_info(self, file_type_map=None, parameters=None):
+        """Parse one BI500 Info file."""
+        if file_type_map is None:
+            file_type_map = self.file_type_map
+        if parameters is None:
+            parameters = self.parameters
+
+        # BI500 Info file parameters for unpacking
+        info_file_format = ">llllllllfffllfff"
+        info_vars = (
+            "Release",
+            "Nation",
+            "Ship",
+            "Survey",
+            "Frequency",
+            "Transceiver",
+            "StartDate",
+            "StartTime",
+            "StartLatitude",
+            "StartLongitude",
+            "StartDistance",
+            "StopDate",
+            "StopTime",
+            "StopLatitude",
+            "StopLongitude",
+            "StopDistance",
+        )
+
+        with self.fsmap.fs.open(file_type_map["-Info"], mode="rb") as bi500_info:
+            info_data = unpack(info_file_format, bi500_info.read())
+
+        for name, data in zip(info_vars, info_data):
+            parameters[camelcase2snakecase(name)].append(data)
+
+    def load_BI500_ping(
+        self,
+        file_type_map=None,
+        ping_data=None,
+        index_counts=None,
+    ):
+        """Parse one BI500 Ping file."""
+        if file_type_map is None:
+            file_type_map = self.file_type_map
+        if ping_data is None:
+            ping_data = self.ping_data
+        if index_counts is None:
+            index_counts = self.index_counts
+
+        with self.fsmap.fs.open(file_type_map["-Ping"], mode="rb") as bi500_ping:
+            eof = False
+            while not eof:
+                data_read = bi500_ping.read(PV_FILE_SIZE)
+                if data_read:
+                    data = unpack(PV_FILE_FORMAT, data_read)
+                    for name, value in zip(PV_FIELDS, data):
+                        key = camelcase2snakecase(name)
+                        if name in ("PelagicCount", "BottomCount", "EchotraceCount"):
+                            index_counts[key].append(value)
+                        ping_data[key].append(value)
+                else:
+                    eof = True
+
+    def load_BI500_vlog(self, file_type_map=None, vlog_data=None):
+        """Parse one BI500 Vlog file."""
+        if file_type_map is None:
+            file_type_map = self.file_type_map
+        if vlog_data is None:
+            vlog_data = self.vlog_data
+
+        vlog_file = file_type_map.get("-Vlog")
+        if vlog_file is None:
+            return
+
+        with self.fsmap.fs.open(vlog_file, mode="rb") as bi500_vlog:
+            eof = False
+            while not eof:
+                data_read = bi500_vlog.read(PV_FILE_SIZE)
+                if data_read:
+                    data = unpack(PV_FILE_FORMAT, data_read)
+                    for name, value in zip(PV_FIELDS, data):
+                        vlog_data[camelcase2snakecase(name)].append(value)
+                else:
+                    eof = True
+
+    def _load_BI500_data(self, file_type_map, index_counts, unpacked_data):
+        """Parse one BI500 Data file."""
+        start_format = ">"
+        trace_vars = ("TargetDepth", "CompTS", "UncompTS", "Alongship", "Athwartship")
+
+        with self.fsmap.fs.open(file_type_map["-Data"], mode="rb") as bi500_data:
+            num_pings = len(index_counts["pelagic_count"])
+
+            for i in range(num_pings):
+                pelagic_count = index_counts["pelagic_count"][i]
+                bottom_count = index_counts["bottom_count"][i]
+                trace_count = index_counts["echotrace_count"][i]
+
+                ping_size = pelagic_count * 2 + bottom_count * 2 + trace_count * 20
+                loaded_data = bi500_data.read(ping_size)
+
+                if not loaded_data:
+                    break
+
+                pelagic_format = start_format + "h" * pelagic_count
+                bottom_format = "h" * bottom_count
+                trace_format = "fffff" * trace_count
+                ping_format = pelagic_format + bottom_format + trace_format
+
+                values = np.asarray(unpack(ping_format, loaded_data), dtype=np.float64)
+
+                # Convert pelagic/bottom power samples to dB units.
+                values[: pelagic_count + bottom_count] *= 10 * np.log10(2) / 256
+
+                unpacked_data["pelagic"].append(values[:pelagic_count])
+                unpacked_data["bottom"].append(values[pelagic_count : pelagic_count + bottom_count])
+
+                for trace_num in range(trace_count):
+                    start = pelagic_count + bottom_count + trace_num * 5
+                    trace_data = values[start : start + 5]
+
+                    for name, value in zip(trace_vars, trace_data):
+                        unpacked_data[name].append(value)
+
+                # Preserve the existing placeholder convention when no
+                # single-target trace data are available for a ping.
+                if trace_count == 0:
+                    for name in trace_vars:
+                        unpacked_data[name].append(float(0))
+
+    def parse_raw(self):
+        """Parse all BI500 channel file sets for one acquisition."""
+        for _, file_type_map in sorted(self.file_set_map.items()):
+            parameters = defaultdict(list)
+            ping_data = defaultdict(list)
+            vlog_data = defaultdict(list)
+            index_counts = defaultdict(list)
+            unpacked_data = defaultdict(list)
+
+            self.load_BI500_info(
+                file_type_map=file_type_map,
+                parameters=parameters,
+            )
+            self.load_BI500_ping(
+                file_type_map=file_type_map,
+                ping_data=ping_data,
+                index_counts=index_counts,
+            )
+            self.load_BI500_vlog(
+                file_type_map=file_type_map,
+                vlog_data=vlog_data,
+            )
+            self._load_BI500_data(
+                file_type_map=file_type_map,
+                index_counts=index_counts,
+                unpacked_data=unpacked_data,
+            )
+
+            frequency = int(parameters["frequency"][0])
+            transceiver = int(parameters["transceiver"][0])
+            channel_id = f"BI500-F{frequency}-T{transceiver:02d}"
+
+            self.channel_data[channel_id] = {
+                "file_type_map": file_type_map,
+                "parameters": parameters,
+                "ping_data": ping_data,
+                "vlog_data": vlog_data,
+                "index_counts": index_counts,
+                "unpacked_data": unpacked_data,
+            }
+
+        # Preserve the current single-channel attributes as aliases to the
+        # first channel so existing BI500 API/grouping code remains usable.
+        first_channel_data = next(iter(self.channel_data.values()))
+        self.file_type_map = first_channel_data["file_type_map"]
+        self.parameters = first_channel_data["parameters"]
+        self.ping_data = first_channel_data["ping_data"]
+        self.vlog_data = first_channel_data["vlog_data"]
+        self.index_counts = first_channel_data["index_counts"]
+        self.unpacked_data = first_channel_data["unpacked_data"]
diff --git a/echopype/convert/set_groups_bi500.py b/echopype/convert/set_groups_bi500.py
new file mode 100644
index 000000000..8f2e3e587
--- /dev/null
+++ b/echopype/convert/set_groups_bi500.py
@@ -0,0 +1,954 @@
+import datetime
+from contextlib import contextmanager
+from typing import List
+
+import numpy as np
+import xarray as xr
+
+from ..utils.coding import set_time_encodings
+from ..utils.log import _init_logger
+from ..utils.prov import echopype_prov_attrs, source_files_vars
+
+# fmt: off
+from .set_groups_base import SetGroupsBase
+
+# fmt: on
+
+logger = _init_logger(__name__)
+
+
+class SetGroupsBI500(SetGroupsBase):
+    """Class for saving groups to netcdf or zarr from BI500 data files."""
+
+    beamgroups_possible = [
+        {
+            "name": "Beam_group1",
+            "descr": ("Contains BI500 channel, ping, and echogram geometry metadata."),
+        }
+    ]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._beamgroups = self.beamgroups_possible
+
+    def _channel_items(self):
+        """Return parsed BI500 channel data, with single-channel fallback."""
+        channel_data = getattr(self.parser_obj, "channel_data", None)
+        if channel_data:
+            return channel_data.items()
+
+        return [
+            (
+                self._get_channel_id(),
+                {
+                    "file_type_map": self.parser_obj.file_type_map,
+                    "parameters": self.parser_obj.parameters,
+                    "ping_data": self.parser_obj.ping_data,
+                    "vlog_data": self.parser_obj.vlog_data,
+                    "index_counts": self.parser_obj.index_counts,
+                    "unpacked_data": self.parser_obj.unpacked_data,
+                },
+            )
+        ]
+
+    @contextmanager
+    def _use_channel_data(self, channel_data):
+        """Temporarily expose one parsed BI500 channel through legacy attributes."""
+        attr_names = (
+            "file_type_map",
+            "parameters",
+            "ping_data",
+            "vlog_data",
+            "index_counts",
+            "unpacked_data",
+        )
+        previous = {name: getattr(self.parser_obj, name) for name in attr_names}
+
+        try:
+            for name in attr_names:
+                setattr(self.parser_obj, name, channel_data[name])
+            yield
+        finally:
+            for name, value in previous.items():
+                setattr(self.parser_obj, name, value)
+
+    def set_platform(self) -> xr.Dataset:
+        """Set Platform data using the union of native BI500 channel timestamps."""
+        datasets = []
+        for _, channel_data in self._channel_items():
+            with self._use_channel_data(channel_data):
+                datasets.append(self._set_platform_single())
+
+        ds = datasets[0]
+        for other in datasets[1:]:
+            ds = ds.combine_first(other)
+
+        return set_time_encodings(ds)
+
+    @staticmethod
+    def _build_ping_time(dates, times) -> np.ndarray:
+        """Combine BI500 YYYYMMDD date and seconds-since-midnight time arrays."""
+        ping_time = np.empty(len(dates), dtype="datetime64[ns]")
+        for i, (date, time) in enumerate(zip(dates, times)):
+            year = date // 10000
+            month = (date // 100) % 100
+            day = date % 100
+            dt = datetime.datetime(
+                year, month, day, tzinfo=datetime.timezone.utc
+            ) + datetime.timedelta(seconds=int(time))
+            ping_time[i] = np.datetime64(dt.replace(tzinfo=None), "ns")
+        return ping_time
+
+    def _get_ping_time(self) -> np.ndarray:
+        ping_data = self.parser_obj.ping_data
+        return self._build_ping_time(
+            np.array(ping_data["date"], dtype=np.int64),
+            np.array(ping_data["time"], dtype=np.int64),
+        )
+
+    def _get_ping_time_vlog(self) -> np.ndarray:
+        vlog_data = self.parser_obj.vlog_data
+        return self._build_ping_time(
+            np.array(vlog_data["date"], dtype=np.int64),
+            np.array(vlog_data["time"], dtype=np.int64),
+        )
+
+    def _set_platform_single(self) -> xr.Dataset:
+        """Set the Platform group."""
+        ping_data = self.parser_obj.ping_data
+        vlog_data = self.parser_obj.vlog_data
+        ping_time = self._get_ping_time()
+        ping_time_vlog = self._get_ping_time_vlog()
+
+        platform_attrs = {
+            "platform_name": "",
+            "platform_type": "",
+            "platform_code_ICES": "",
+        }
+        if self.parser_obj.parameters.get("ship"):
+            platform_attrs["platform_code_ICES"] = str(self.parser_obj.parameters["ship"][0])
+
+        ds = xr.Dataset(
+            {
+                "latitude": (
+                    ["ping_time"],
+                    np.array(ping_data["latitude"], dtype=np.float64),
+                    self._varattrs["platform_var_default"]["latitude"],
+                ),
+                "latitude_vlog": (
+                    ["ping_time_vlog"],
+                    np.array(vlog_data["latitude"], dtype=np.float64),
+                    {
+                        "long_name": "Vessel log latitude",
+                        "units": "degrees",
+                    },
+                ),
+                "longitude": (
+                    ["ping_time"],
+                    np.array(ping_data["longitude"], dtype=np.float64),
+                    self._varattrs["platform_var_default"]["longitude"],
+                ),
+                "longitude_vlog": (
+                    ["ping_time_vlog"],
+                    np.array(vlog_data["longitude"], dtype=np.float64),
+                    {
+                        "long_name": "Vessel log longitude",
+                        "units": "degrees",
+                    },
+                ),
+                "bottom_depth": (
+                    ["ping_time"],
+                    np.array(ping_data["bottom_depth"], dtype=np.float64),
+                    {
+                        "long_name": "Bottom depth",
+                        "units": "m",
+                        "positive": "down",
+                    },
+                ),
+                "bottom_depth_vlog": (
+                    ["ping_time_vlog"],
+                    np.array(vlog_data["bottom_depth"], dtype=np.float64),
+                    {
+                        "long_name": "Bottom depth from vlog",
+                        "units": "m",
+                        "positive": "down",
+                    },
+                ),
+                "vessel_log_distance": (
+                    ["ping_time"],
+                    np.array(ping_data["distance"], dtype=np.float64),
+                    {
+                        "long_name": "Vessel log distance",
+                        "units": "m",
+                        "comment": "Distance along track from the vessel log.",
+                    },
+                ),
+                "vessel_log_distance_vlog": (
+                    ["ping_time_vlog"],
+                    np.array(vlog_data["distance"], dtype=np.float64),
+                    {
+                        "long_name": "Vessel log distance from vlog",
+                        "units": "m",
+                        "comment": "Distance along track from the vessel log from vlog.",
+                    },
+                ),
+            },
+            coords={
+                "ping_time": (
+                    ["ping_time"],
+                    ping_time,
+                    {
+                        "axis": "T",
+                        "long_name": "Timestamps for platform data",
+                        "standard_name": "time",
+                        "comment": "Combined from BI500 -Ping Date and Time fields.",
+                    },
+                ),
+                "ping_time_vlog": (
+                    ["ping_time_vlog"],
+                    ping_time_vlog,
+                    {
+                        "axis": "T",
+                        "long_name": "Timestamps for platform data from vlog",
+                        "standard_name": "time",
+                        "comment": "Combined from BI500 -Vlog Date and Time fields.",
+                    },
+                ),
+            },
+        )
+        ds = ds.assign_attrs(platform_attrs)
+        return set_time_encodings(ds)
+
+    def _get_channel_id(self) -> str:
+        """Return a single BI500 channel identifier."""
+        parameters = self.parser_obj.parameters
+        frequency = int(parameters["frequency"][0])
+        transceiver = int(parameters["transceiver"][0])
+        return f"BI500-F{frequency}-T{transceiver:02d}"
+
+    def set_env(self) -> xr.Dataset:
+        """Set Environment data for all BI500 channels."""
+        datasets = []
+        for _, channel_data in self._channel_items():
+            with self._use_channel_data(channel_data):
+                datasets.append(self._set_env_single())
+
+        if len(datasets) == 1:
+            return datasets[0]
+
+        ds = xr.concat(
+            datasets,
+            dim="channel",
+            join="outer",
+            data_vars=["absorption_indicative"],
+            coords="minimal",
+            compat="override",
+        )
+        return set_time_encodings(ds)
+
+    def _set_env_single(self) -> xr.Dataset:
+        """Set the Environment group."""
+        channel_id = self._get_channel_id()
+
+        ds = xr.Dataset(
+            {
+                "absorption_indicative": (
+                    ["channel"],
+                    [np.nan],
+                    {
+                        "long_name": "Indicative acoustic absorption",
+                        "units": "dB/m",
+                        "valid_min": 0.0,
+                    },
+                ),
+                "sound_speed_indicative": (
+                    [],
+                    np.nan,
+                    {
+                        "long_name": "Indicative sound speed",
+                        "standard_name": "speed_of_sound_in_sea_water",
+                        "units": "m/s",
+                        "valid_min": 0.0,
+                    },
+                ),
+            },
+            coords={
+                "channel": (
+                    ["channel"],
+                    [channel_id],
+                    self._varattrs["beam_coord_default"]["channel"],
+                ),
+            },
+        )
+        return set_time_encodings(ds)
+
+    def set_sonar(self) -> xr.Dataset:
+        """Set the Sonar group."""
+        parameters = self.parser_obj.parameters
+        beam_groups_vars, beam_groups_coord = self._beam_groups_vars()
+        ds = xr.Dataset(beam_groups_vars, coords=beam_groups_coord)
+
+        sonar_attr_dict = {
+            "sonar_manufacturer": "Bergen Integrator",
+            "sonar_model": self.sonar_model,
+            "sonar_serial_number": "",
+            "sonar_software_name": "BI500",
+            "sonar_software_version": str(int(parameters["release"][0])),
+            "sonar_type": "echosounder",
+        }
+        ds = ds.assign_attrs(sonar_attr_dict)
+        return set_time_encodings(ds)
+
+    @staticmethod
+    def _build_pelagic_depth(
+        upper: np.ndarray,
+        lower: np.ndarray,
+        sample_count: int,
+    ) -> np.ndarray:
+        """Construct pelagic sample-centre depths from BI500 depth bounds."""
+        sample_width = (lower - upper) / sample_count
+
+        return (
+            upper[:, np.newaxis]
+            + (np.arange(sample_count, dtype=np.float64) + 0.5) * sample_width[:, np.newaxis]
+        )
+
+    @staticmethod
+    def _build_bottom_depth(
+        bottom_depth: np.ndarray,
+        upper_offset: np.ndarray,
+        lower_offset: np.ndarray,
+        sample_count: int,
+    ) -> np.ndarray:
+        """Construct bottom-window sample-centre depths."""
+        window_start = bottom_depth - upper_offset
+        window_stop = bottom_depth - lower_offset
+        sample_width = (window_stop - window_start) / sample_count
+
+        return (
+            window_start[:, np.newaxis]
+            + (np.arange(sample_count, dtype=np.float64) + 0.5) * sample_width[:, np.newaxis]
+        )
+
+    def set_calibrated(self) -> xr.Dataset:
+        """Create calibrated BI500 products for all channels in one acquisition."""
+        datasets = []
+        for _, channel_data in self._channel_items():
+            with self._use_channel_data(channel_data):
+                datasets.append(self._set_calibrated_single())
+
+        if len(datasets) == 1:
+            return datasets[0]
+
+        ds = xr.concat(
+            datasets,
+            dim="channel",
+            join="outer",
+            data_vars="all",
+            coords="minimal",
+            compat="override",
+        )
+        return set_time_encodings(ds)
+
+    def _set_calibrated_single(self) -> xr.Dataset:
+        """Create a dataset containing calibrated BI500 echogram products."""
+        parameters = self.parser_obj.parameters
+        ping_data = self.parser_obj.ping_data
+        unpacked_data = self.parser_obj.unpacked_data
+
+        ping_time = self._get_ping_time()
+        channel_id = self._get_channel_id()
+        frequency = float(parameters["frequency"][0])
+
+        sv = self._stack_samples(unpacked_data["pelagic"])
+        sv_bottom = self._stack_samples(unpacked_data["bottom"])
+
+        pelagic_upper = np.asarray(
+            ping_data["pelagic_upper"],
+            dtype=np.float64,
+        )
+        pelagic_lower = np.asarray(
+            ping_data["pelagic_lower"],
+            dtype=np.float64,
+        )
+        depth = self._build_pelagic_depth(
+            upper=pelagic_upper,
+            lower=pelagic_lower,
+            sample_count=sv.shape[1],
+        )
+        bottom_depth = np.asarray(
+            ping_data["bottom_depth"],
+            dtype=np.float64,
+        )
+        bottom_upper = np.asarray(
+            ping_data["bottom_upper"],
+            dtype=np.float64,
+        )
+        bottom_lower = np.asarray(
+            ping_data["bottom_lower"],
+            dtype=np.float64,
+        )
+        depth_bottom = self._build_bottom_depth(
+            bottom_depth=bottom_depth,
+            upper_offset=bottom_upper,
+            lower_offset=bottom_lower,
+            sample_count=sv_bottom.shape[1],
+        )
+        traces = self._collect_target_traces()
+        n_targets = len(traces["single_target_depth"])
+
+        single_target = np.arange(
+            n_targets,
+            dtype=np.int64,
+        )
+
+        single_target_ping_index = np.asarray(
+            traces["ping_index"],
+            dtype=np.int64,
+        )
+
+        single_target_ping_time = ping_time[single_target_ping_index]
+
+        ds = xr.Dataset(
+            data_vars={
+                "Sv": (
+                    ["channel", "ping_time", "range_sample"],
+                    sv[np.newaxis, :, :].astype(np.float32),
+                    {
+                        "long_name": "Volume backscattering strength",
+                        "units": "dB",
+                        "comment": (
+                            "Nominally calibrated pelagic Sv recorded " "in the BI500 -Data file."
+                        ),
+                    },
+                ),
+                "Sv_bottom": (
+                    ["channel", "ping_time", "range_sample_bottom"],
+                    sv_bottom[np.newaxis, :, :].astype(np.float32),
+                    {
+                        "long_name": "Bottom volume backscattering strength",
+                        "units": "dB",
+                        "comment": (
+                            "Nominally calibrated bottom Sv recorded " "in the BI500 -Data file."
+                        ),
+                    },
+                ),
+                "frequency_nominal": (
+                    ["channel"],
+                    [frequency],
+                    {
+                        "long_name": "Transducer frequency",
+                        "standard_name": "sound_frequency",
+                        "units": "Hz",
+                        "valid_min": 0.0,
+                    },
+                ),
+                "depth": (
+                    ["channel", "ping_time", "range_sample"],
+                    depth[np.newaxis, :, :],
+                    {
+                        "long_name": "Pelagic echogram sample depth",
+                        "standard_name": "depth",
+                        "units": "m",
+                        "positive": "down",
+                        "comment": (
+                            "Depth below the sea surface reconstructed from "
+                            "BI500 PelagicUpper and PelagicLower."
+                        ),
+                    },
+                ),
+                "depth_bottom": (
+                    ["channel", "ping_time", "range_sample_bottom"],
+                    depth_bottom[np.newaxis, :, :],
+                    {
+                        "long_name": "Bottom echogram sample depth",
+                        "standard_name": "depth",
+                        "units": "m",
+                        "positive": "down",
+                        "comment": (
+                            "Depth below the sea surface reconstructed from BI500 BottomDepth, "
+                            "BottomUpper, and BottomLower."
+                        ),
+                    },
+                ),
+                "pelagic_upper": (
+                    ["channel", "ping_time"],
+                    pelagic_upper[np.newaxis, :],
+                    {
+                        "long_name": "Pelagic echogram upper range bound",
+                        "units": "m",
+                    },
+                ),
+                "pelagic_lower": (
+                    ["channel", "ping_time"],
+                    pelagic_lower[np.newaxis, :],
+                    {
+                        "long_name": "Pelagic echogram lower range bound",
+                        "units": "m",
+                    },
+                ),
+                "bottom_upper": (
+                    ["channel", "ping_time"],
+                    bottom_upper[np.newaxis, :],
+                    {
+                        "long_name": "Bottom echogram upper range offset",
+                        "units": "m",
+                    },
+                ),
+                "bottom_lower": (
+                    ["channel", "ping_time"],
+                    bottom_lower[np.newaxis, :],
+                    {
+                        "long_name": "Bottom echogram lower range offset",
+                        "units": "m",
+                    },
+                ),
+                "single_target_identifier": (
+                    ["single_target"],
+                    single_target,
+                    {
+                        "long_name": "Index of single target detected",
+                    },
+                ),
+                "ping_index": (
+                    ["single_target"],
+                    single_target_ping_index,
+                    {
+                        "long_name": (
+                            "Index of the BI500 ping containing the " "single-target detection"
+                        ),
+                    },
+                ),
+                "single_target_ping_time": (
+                    ["single_target"],
+                    single_target_ping_time,
+                    {
+                        "long_name": "Ping time of single-target detection",
+                        "standard_name": "time",
+                    },
+                ),
+                "single_target_depth": (
+                    ["single_target"],
+                    np.asarray(
+                        traces["single_target_depth"],
+                        dtype=np.float64,
+                    ),
+                    {
+                        "long_name": "Depth of single target detected",
+                        "standard_name": "depth",
+                        "units": "m",
+                        "positive": "down",
+                        "comment": "Target depth reported directly by BI500.",
+                    },
+                ),
+                "single_target_alongship_angle": (
+                    ["single_target"],
+                    np.asarray(
+                        traces["single_target_alongship_angle"],
+                        dtype=np.float64,
+                    ),
+                    {
+                        "long_name": (
+                            "Single target arrival angle in the " "minor beam coordinate"
+                        ),
+                        "units": "arc_degree",
+                        "valid_range": [-180.0, 180.0],
+                    },
+                ),
+                "single_target_athwartship_angle": (
+                    ["single_target"],
+                    np.asarray(
+                        traces["single_target_athwartship_angle"],
+                        dtype=np.float64,
+                    ),
+                    {
+                        "long_name": (
+                            "Single target arrival angle in the " "major beam coordinate"
+                        ),
+                        "units": "arc_degree",
+                        "valid_range": [-180.0, 180.0],
+                    },
+                ),
+                "uncompensated_TS": (
+                    ["single_target"],
+                    np.asarray(
+                        traces["uncompensated_TS"],
+                        dtype=np.float64,
+                    ),
+                    {
+                        "long_name": (
+                            "Calculated Target Strength (re 1 m2) "
+                            "uncompensated for off-axis angle"
+                        ),
+                        "units": "dB",
+                        "comment": "Uncompensated target strength generated directly by BI500.",
+                    },
+                ),
+                "compensated_TS": (
+                    ["single_target"],
+                    np.asarray(
+                        traces["compensated_TS"],
+                        dtype=np.float64,
+                    ),
+                    {
+                        "long_name": (
+                            "Calculated Target Strength (re 1 m2) "
+                            "after compensation for off-axis angle"
+                        ),
+                        "units": "dB",
+                        "comment": "Beam-compensated target strength generated directly by BI500.",
+                    },
+                ),
+            },
+            coords={
+                "channel": (
+                    ["channel"],
+                    [channel_id],
+                    self._varattrs["beam_coord_default"]["channel"],
+                ),
+                "ping_time": (
+                    ["ping_time"],
+                    ping_time,
+                    self._varattrs["beam_coord_default"]["ping_time"],
+                ),
+                "range_sample": (
+                    ["range_sample"],
+                    np.arange(sv.shape[1]),
+                    self._varattrs["beam_coord_default"]["range_sample"],
+                ),
+                "range_sample_bottom": (
+                    ["range_sample_bottom"],
+                    np.arange(sv_bottom.shape[1]),
+                    {
+                        "long_name": "Along-range bottom sample number, base 0",
+                    },
+                ),
+                "single_target": (
+                    ["single_target"],
+                    single_target,
+                    {
+                        "long_name": "Single-target detection index",
+                    },
+                ),
+            },
+            attrs={
+                "processing_function": "open_raw",
+                "source_sonar_model": "BI500",
+                "comment": ("Automatically generated calibrated quantities by the BI500 system."),
+            },
+        )
+
+        return set_time_encodings(ds)
+
+    @staticmethod
+    def _stack_samples(samples: list) -> np.ndarray:
+        """Stack per-ping sample arrays, padding shorter pings with NaN."""
+        n_pings = len(samples)
+        max_len = max(len(sample) for sample in samples)
+        stacked = np.full((n_pings, max_len), np.nan, dtype=np.float64)
+        for i, sample in enumerate(samples):
+            stacked[i, : len(sample)] = sample
+        return stacked
+
+    def _collect_target_traces(self) -> dict:
+        """Collect BI500 single-target values and their source ping indices."""
+        trace_fields = {
+            "single_target_depth": "TargetDepth",
+            "compensated_TS": "CompTS",
+            "uncompensated_TS": "UncompTS",
+            "single_target_alongship_angle": "Alongship",
+            "single_target_athwartship_angle": "Athwartship",
+        }
+
+        collected = {name: [] for name in trace_fields}
+        collected["ping_index"] = []
+
+        trace_idx = 0
+
+        for ping_index, count in enumerate(self.parser_obj.index_counts["echotrace_count"]):
+            # The parser inserts one zero placeholder when a ping has no traces.
+            if count == 0:
+                trace_idx += 1
+                continue
+
+            for _ in range(count):
+                collected["ping_index"].append(ping_index)
+
+                for output_name, parser_name in trace_fields.items():
+                    collected[output_name].append(
+                        float(self.parser_obj.unpacked_data[parser_name][trace_idx])
+                    )
+
+                trace_idx += 1
+
+        return collected
+
+    def set_beam(self) -> List[xr.Dataset]:
+        """Set Sonar/Beam_group1 for all BI500 channels."""
+        datasets = []
+        for _, channel_data in self._channel_items():
+            with self._use_channel_data(channel_data):
+                datasets.append(self._set_beam_single()[0])
+
+        if len(datasets) == 1:
+            return [datasets[0]]
+
+        ds = xr.concat(
+            datasets,
+            dim="channel",
+            join="outer",
+            data_vars="all",
+            coords="minimal",
+            compat="override",
+        )
+        return [set_time_encodings(ds)]
+
+    def _set_beam_single(self) -> List[xr.Dataset]:
+        """Set the Sonar/Beam_group1 group."""
+        parameters = self.parser_obj.parameters
+        ping_data = self.parser_obj.ping_data
+        vlog_data = self.parser_obj.vlog_data
+
+        ping_time = self._get_ping_time()
+        ping_time_vlog = self._get_ping_time_vlog()
+        channel_id = self._get_channel_id()
+        frequency = float(parameters["frequency"][0])
+
+        ds = xr.Dataset(
+            {
+                "frequency_nominal": (
+                    ["channel"],
+                    [frequency],
+                    {
+                        "units": "Hz",
+                        "long_name": "Transducer frequency",
+                        "valid_min": 0.0,
+                        "standard_name": "sound_frequency",
+                    },
+                ),
+                "transceiver_channel_number": (
+                    ["channel"],
+                    [int(parameters["transceiver"][0])],
+                    {"long_name": "Transceiver channel number"},
+                ),
+                "echogram_type": (
+                    ["ping_time"],
+                    np.array(ping_data["echogram_type"], dtype=np.int64),
+                    {
+                        "long_name": "Echogram data type",
+                    },
+                ),
+                "echogram_type_vlog": (
+                    ["ping_time_vlog"],
+                    np.array(vlog_data["echogram_type"], dtype=np.int64),
+                    {
+                        "long_name": "Echogram data type from vlog",
+                    },
+                ),
+                "pelagic_upper": (
+                    ["channel", "ping_time"],
+                    np.array(ping_data["pelagic_upper"], dtype=np.float64)[np.newaxis, :],
+                    {
+                        "long_name": "Pelagic echogram upper depth bound",
+                        "units": "m",
+                        "positive": "down",
+                        "comment": "Referenced to the sea surface.",
+                    },
+                ),
+                "pelagic_lower": (
+                    ["channel", "ping_time"],
+                    np.array(ping_data["pelagic_lower"], dtype=np.float64)[np.newaxis, :],
+                    {
+                        "long_name": "Pelagic echogram lower depth bound",
+                        "units": "m",
+                        "positive": "down",
+                        "comment": "Referenced to the sea surface.",
+                    },
+                ),
+                "pelagic_upper_vlog": (
+                    ["channel", "ping_time_vlog"],
+                    np.array(vlog_data["pelagic_upper"], dtype=np.float64)[np.newaxis, :],
+                    {
+                        "long_name": "Pelagic echogram upper depth bound from vlog",
+                        "units": "m",
+                        "positive": "down",
+                        "comment": "Referenced to the sea surface.",
+                    },
+                ),
+                "pelagic_lower_vlog": (
+                    ["channel", "ping_time_vlog"],
+                    np.array(vlog_data["pelagic_lower"], dtype=np.float64)[np.newaxis, :],
+                    {
+                        "long_name": "Pelagic echogram lower depth bound from vlog",
+                        "units": "m",
+                        "positive": "down",
+                        "comment": "Referenced to the sea surface.",
+                    },
+                ),
+                "bottom_upper": (
+                    ["channel", "ping_time"],
+                    np.array(ping_data["bottom_upper"], dtype=np.float64)[np.newaxis, :],
+                    {
+                        "long_name": "Bottom echogram upper depth offset",
+                        "units": "m",
+                        "comment": (
+                            "Referenced to the detected bottom; "
+                            "positive values are above the bottom."
+                        ),
+                    },
+                ),
+                "bottom_lower": (
+                    ["channel", "ping_time"],
+                    np.array(ping_data["bottom_lower"], dtype=np.float64)[np.newaxis, :],
+                    {
+                        "long_name": "Bottom echogram lower depth offset",
+                        "units": "m",
+                        "comment": (
+                            "Referenced to the detected bottom; "
+                            "positive values are above the bottom."
+                        ),
+                    },
+                ),
+                "bottom_upper_vlog": (
+                    ["channel", "ping_time_vlog"],
+                    np.array(vlog_data["bottom_upper"], dtype=np.float64)[np.newaxis, :],
+                    {
+                        "long_name": "Bottom echogram upper depth offset from vlog",
+                        "units": "m",
+                        "comment": (
+                            "Referenced to the detected bottom; "
+                            "positive values are above the bottom."
+                        ),
+                    },
+                ),
+                "bottom_lower_vlog": (
+                    ["channel", "ping_time_vlog"],
+                    np.array(vlog_data["bottom_lower"], dtype=np.float64)[np.newaxis, :],
+                    {
+                        "long_name": "Bottom echogram lower depth offset from vlog",
+                        "units": "m",
+                        "comment": (
+                            "Referenced to the detected bottom; "
+                            "positive values are above the bottom."
+                        ),
+                    },
+                ),
+            },
+            coords={
+                "channel": (
+                    ["channel"],
+                    [channel_id],
+                    self._varattrs["beam_coord_default"]["channel"],
+                ),
+                "ping_time": (
+                    ["ping_time"],
+                    ping_time,
+                    self._varattrs["beam_coord_default"]["ping_time"],
+                ),
+                "ping_time_vlog": (
+                    ["ping_time_vlog"],
+                    ping_time_vlog,
+                    {
+                        "axis": "T",
+                        "long_name": "Timestamps for vlog beam metadata",
+                        "standard_name": "time",
+                    },
+                ),
+            },
+        )
+        return [set_time_encodings(ds)]
+
+    def set_vendor(self) -> xr.Dataset:
+        """Set the Vendor_specific group."""
+        parameters = self.parser_obj.parameters
+
+        return xr.Dataset(
+            {
+                "start_latitude": (
+                    [],
+                    float(parameters["start_latitude"][0]),
+                    {},
+                ),
+                "start_longitude": (
+                    [],
+                    float(parameters["start_longitude"][0]),
+                    {},
+                ),
+                "start_distance": (
+                    [],
+                    float(parameters["start_distance"][0]),
+                    {},
+                ),
+                "stop_latitude": (
+                    [],
+                    float(parameters["stop_latitude"][0]),
+                    {},
+                ),
+                "stop_longitude": (
+                    [],
+                    float(parameters["stop_longitude"][0]),
+                    {},
+                ),
+                "stop_distance": (
+                    [],
+                    float(parameters["stop_distance"][0]),
+                    {},
+                ),
+            }
+        )
+
+    def set_provenance(self) -> xr.Dataset:
+        """Set the Provenance group."""
+        prov_dict = echopype_prov_attrs(process_type="conversion")
+
+        if getattr(self.parser_obj, "file_set_map", None):
+            source_files = [
+                file_type_map[file_type]
+                for file_type_map in self.parser_obj.file_set_map.values()
+                for file_type in self.parser_obj.file_types
+                if file_type_map.get(file_type)
+            ]
+        else:
+            source_files = [
+                self.parser_obj.file_type_map[file_type]
+                for file_type in self.parser_obj.file_types
+                if self.parser_obj.file_type_map.get(file_type)
+            ]
+        if not source_files:
+            source_files = [self.input_file]
+
+        files_vars = source_files_vars(source_files)
+        parameters = self.parser_obj.parameters
+
+        ds = xr.Dataset(
+            data_vars={
+                **files_vars["source_files_var"],
+                "nation_code": (
+                    [],
+                    int(parameters["nation"][0]),
+                    {
+                        "long_name": "Nation code",
+                        "comment": "Reference table nation code from BI500 -Info file.",
+                    },
+                ),
+                "ship_code": (
+                    [],
+                    int(parameters["ship"][0]),
+                    {
+                        "long_name": "Ship code",
+                        "comment": "Reference table ship code from BI500 -Info file.",
+                    },
+                ),
+                "survey_code": (
+                    [],
+                    int(parameters["survey"][0]),
+                    {
+                        "long_name": "Survey code",
+                        "comment": "Reference table survey code from BI500 -Info file.",
+                    },
+                ),
+            },
+            coords=files_vars["source_files_coord"],
+            attrs=prov_dict,
+        )
+        return ds
diff --git a/echopype/core.py b/echopype/core.py
index 3d12ff000..bf0940079 100644
--- a/echopype/core.py
+++ b/echopype/core.py
@@ -6,6 +6,7 @@
 from typing_extensions import Literal
 
 from .convert.parse_ad2cp import ParseAd2cp
+from .convert.parse_bi500 import ParseBI500
 from .convert.parse_ek60 import ParseEK60
 from .convert.parse_ek80 import ParseEK80
 from .convert.parse_uls5 import ParseULS5
@@ -13,12 +14,15 @@
 from .convert.set_groups_ad2cp import SetGroupsAd2cp
 from .convert.set_groups_azfp import SetGroupsAZFP
 from .convert.set_groups_azfp6 import SetGroupsAZFP6
+from .convert.set_groups_bi500 import SetGroupsBI500
 from .convert.set_groups_ek60 import SetGroupsEK60
 from .convert.set_groups_ek80 import SetGroupsEK80
 
 if TYPE_CHECKING:
     # Please keep SonarModelsHint updated with the keys of the SONAR_MODELS dict
-    SonarModelsHint = Literal["AZFP", "AZFP6", "EK60", "ES70", "EK80", "ES80", "EA640", "AD2CP"]
+    SonarModelsHint = Literal[
+        "AZFP", "AZFP6", "EK60", "ES70", "EK80", "ES80", "EA640", "AD2CP", "BI500"
+    ]
     PathHint = Union[str, os.PathLike, FSMap]
     FileFormatHint = Literal[".nc", ".zarr"]
     EngineHint = Literal["netcdf4", "zarr"]
@@ -124,4 +128,14 @@ def inner(test_ext: str):
         "set_groups": SetGroupsAd2cp,
         "family": "AD2CP",
     },
+    "BI500": {
+        "validate_ext": validate_ext(""),
+        "xml": False,
+        "accepts_bot": False,
+        "accepts_idx": False,
+        "parser": ParseBI500,
+        "parsed2zarr": None,
+        "set_groups": SetGroupsBI500,
+        "family": "BI500",
+    },
 }
diff --git a/echopype/tests/convert/test_convert_bi500.py b/echopype/tests/convert/test_convert_bi500.py
new file mode 100644
index 000000000..7e95878d4
--- /dev/null
+++ b/echopype/tests/convert/test_convert_bi500.py
@@ -0,0 +1,402 @@
+import numpy as np
+import pytest
+
+from echopype import open_raw
+from echopype.convert.parse_bi500 import ParseBI500
+
+pytestmark = pytest.mark.integration
+
+
+@pytest.fixture(scope="module")
+def bi500_output(test_path):
+    """Open BI500 test data once for all tests in this module."""
+    bi500_path = test_path["BI500"]
+
+    return open_raw(
+        raw_file=str(bi500_path),
+        sonar_model="BI500",
+    )
+
+
+def test_bi500_invalid_file_path(tmp_path):
+    """Verify that an error is raised when the folder lacks required BI500 files."""
+    invalid_path = tmp_path / "not_bi500_folder"
+    invalid_path.mkdir()
+    (invalid_path / "readme.txt").write_text("not bi500 data")
+
+    with pytest.raises(ValueError, match="Expecting a folder"):
+        open_raw(
+            raw_file=str(invalid_path),
+            sonar_model="BI500",
+        )
+
+
+def test_bi500_echodata_structure(bi500_output):
+    """Verify the BI500 EchoData structure and provenance."""
+    echodata, _ = bi500_output
+    beam = echodata["Sonar/Beam_group1"]
+
+    assert echodata.sonar_model == "BI500"
+    assert len(beam.channel) == 1
+
+    # BI500 values are already calibrated and must not be exposed
+    # as raw backscatter samples.
+    assert "backscatter_r" not in beam
+    assert "backscatter_r_bottom" not in beam
+
+    assert echodata["Platform"].ping_time.shape == (3323,)
+
+    assert echodata["Provenance"].nation_code.values == 31
+    assert echodata["Provenance"].ship_code.values == 445
+    assert echodata["Provenance"].survey_code.values == 2000008
+
+
+def test_bi500_beam_group_dimensions(bi500_output):
+    """Verify Sonar/Beam_group1 dimensions and metadata variables."""
+    echodata, _ = bi500_output
+    beam = echodata["Sonar/Beam_group1"]
+
+    assert beam.sizes["channel"] == 1
+    assert beam.sizes["ping_time"] == 3323
+    assert beam.sizes["ping_time_vlog"] > 0
+
+    assert beam["frequency_nominal"].item() == 11990.0
+    assert beam["transceiver_channel_number"].item() == 1
+    # TODO: Add beam_type once it can be populated from the BI500 data
+    assert "beam_type" not in beam
+    assert beam["channel"].item() == "BI500-F11990-T01"
+
+    ping_time_vars = [
+        "echogram_type",
+        "pelagic_upper",
+        "pelagic_lower",
+        "bottom_upper",
+        "bottom_lower",
+    ]
+    for variable in ping_time_vars:
+        assert variable in beam
+        if variable == "echogram_type":
+            assert beam[variable].dims == ("ping_time",)
+            assert beam[variable].shape == (3323,)
+        else:
+            assert beam[variable].dims == ("channel", "ping_time")
+            assert beam[variable].shape == (1, 3323)
+
+    vlog_size = beam.sizes["ping_time_vlog"]
+    vlog_vars = [
+        "echogram_type_vlog",
+        "pelagic_upper_vlog",
+        "pelagic_lower_vlog",
+        "bottom_upper_vlog",
+        "bottom_lower_vlog",
+    ]
+    for variable in vlog_vars:
+        assert variable in beam
+        if variable == "echogram_type_vlog":
+            assert beam[variable].dims == ("ping_time_vlog",)
+            assert beam[variable].shape == (vlog_size,)
+        else:
+            assert beam[variable].dims == ("channel", "ping_time_vlog")
+            assert beam[variable].shape == (1, vlog_size)
+
+
+def test_bi500_platform_group(bi500_output):
+    """Verify Platform group dimensions and vlog alignment."""
+    echodata, _ = bi500_output
+    platform = echodata["Platform"]
+    beam = echodata["Sonar/Beam_group1"]
+
+    assert platform.sizes["ping_time"] == 3323
+    assert platform.sizes["ping_time_vlog"] == beam.sizes["ping_time_vlog"]
+
+    ping_time_vars = [
+        "latitude",
+        "longitude",
+        "bottom_depth",
+        "vessel_log_distance",
+    ]
+    for variable in ping_time_vars:
+        assert variable in platform
+        assert platform[variable].dims == ("ping_time",)
+        assert platform[variable].shape == (3323,)
+
+    vlog_size = platform.sizes["ping_time_vlog"]
+    vlog_vars = [
+        "latitude_vlog",
+        "longitude_vlog",
+        "bottom_depth_vlog",
+        "vessel_log_distance_vlog",
+    ]
+    for variable in vlog_vars:
+        assert variable in platform
+        assert platform[variable].dims == ("ping_time_vlog",)
+        assert platform[variable].shape == (vlog_size,)
+
+    np.testing.assert_array_equal(
+        platform["ping_time"].values,
+        beam["ping_time"].values,
+    )
+
+
+def test_bi500_environment_and_vendor_groups(bi500_output):
+    """Verify Environment and Vendor_specific group contents."""
+    echodata, _ = bi500_output
+
+    environment = echodata["Environment"]
+    assert environment.sizes == {"channel": 1}
+    assert environment["absorption_indicative"].dims == ("channel",)
+    assert environment["absorption_indicative"].shape == (1,)
+    assert np.isnan(environment["absorption_indicative"].item())
+    assert np.isnan(environment["sound_speed_indicative"].values)
+
+    vendor = echodata["Vendor_specific"]
+    for variable in [
+        "start_latitude",
+        "start_longitude",
+        "start_distance",
+        "stop_latitude",
+        "stop_longitude",
+        "stop_distance",
+    ]:
+        assert variable in vendor
+        assert vendor[variable].dims == ()
+        assert np.isfinite(vendor[variable].values)
+
+
+def test_bi500_sonar_metadata(bi500_output):
+    """Verify Sonar group metadata attributes."""
+    echodata, _ = bi500_output
+    sonar = echodata["Sonar"]
+
+    assert sonar.attrs["sonar_manufacturer"] == "Bergen Integrator"
+    assert sonar.attrs["sonar_model"] == "BI500"
+    assert sonar.attrs["sonar_software_name"] == "BI500"
+    assert sonar.attrs["sonar_type"] == "echosounder"
+    assert isinstance(sonar.attrs["sonar_software_version"], str)
+    assert sonar.attrs["sonar_software_version"]
+
+
+def test_bi500_calibrated_coordinate_alignment(bi500_output):
+    """Verify calibrated dataset coordinates align with EchoData groups."""
+    echodata, ds_cal = bi500_output
+    beam = echodata["Sonar/Beam_group1"]
+    platform = echodata["Platform"]
+
+    np.testing.assert_array_equal(ds_cal["ping_time"].values, platform["ping_time"].values)
+    np.testing.assert_array_equal(ds_cal["ping_time"].values, beam["ping_time"].values)
+    np.testing.assert_array_equal(ds_cal["channel"].values, beam["channel"].values)
+
+    assert ds_cal.sizes["range_sample"] == 500
+    assert ds_cal.sizes["range_sample_bottom"] == 150
+    np.testing.assert_array_equal(ds_cal["range_sample"].values, np.arange(500))
+    np.testing.assert_array_equal(ds_cal["range_sample_bottom"].values, np.arange(150))
+
+    window_vars = [
+        "pelagic_upper",
+        "pelagic_lower",
+        "bottom_upper",
+        "bottom_lower",
+    ]
+    for variable in window_vars:
+        assert ds_cal[variable].dims == ("channel", "ping_time")
+        assert ds_cal[variable].shape == (1, 3323)
+        np.testing.assert_array_equal(
+            ds_cal[variable].values,
+            beam[variable].values,
+        )
+
+
+def test_bi500_calibrated_echograms(bi500_output):
+    """Verify calibrated BI500 Sv products."""
+    _, ds_cal = bi500_output
+
+    assert {"Sv", "Sv_bottom"}.issubset(ds_cal.data_vars)
+
+    sv = ds_cal["Sv"]
+    sv_bottom = ds_cal["Sv_bottom"]
+
+    assert sv.dims == (
+        "channel",
+        "ping_time",
+        "range_sample",
+    )
+    assert sv_bottom.dims == (
+        "channel",
+        "ping_time",
+        "range_sample_bottom",
+    )
+
+    assert sv.shape == (1, 3323, 500)
+    assert sv_bottom.shape == (1, 3323, 150)
+
+    assert np.isfinite(sv.values).any()
+    assert np.isfinite(sv_bottom.values).any()
+
+    assert sv.attrs["units"] == "dB"
+    assert sv_bottom.attrs["units"] == "dB"
+
+    assert ds_cal.channel.values[0] == "BI500-F11990-T01"
+    assert ds_cal["frequency_nominal"].shape == (1,)
+
+    assert ds_cal.attrs["source_sonar_model"] == "BI500"
+    assert ds_cal.attrs["processing_function"] == "open_raw"
+
+
+def test_bi500_depth(bi500_output):
+    """Verify reconstructed BI500 depth products."""
+    _, ds_cal = bi500_output
+
+    depth = ds_cal["depth"]
+    depth_bottom = ds_cal["depth_bottom"]
+
+    assert depth.shape == ds_cal["Sv"].shape
+    assert depth_bottom.shape == ds_cal["Sv_bottom"].shape
+
+    assert depth.attrs["units"] == "m"
+    assert depth.attrs["positive"] == "down"
+
+    assert depth_bottom.attrs["units"] == "m"
+    assert depth_bottom.attrs["positive"] == "down"
+
+    assert np.all(
+        np.diff(
+            depth.isel(channel=0).values,
+            axis=1,
+        )
+        > 0
+    )
+    assert np.all(
+        np.diff(
+            depth_bottom.isel(channel=0).values,
+            axis=1,
+        )
+        > 0
+    )
+
+
+def test_bi500_depth_within_window_bounds(bi500_output):
+    """Verify reconstructed depths stay within BI500 window bounds."""
+    echodata, ds_cal = bi500_output
+
+    depth = ds_cal["depth"].isel(channel=0)
+    pelagic_upper = ds_cal["pelagic_upper"].isel(channel=0)
+    pelagic_lower = ds_cal["pelagic_lower"].isel(channel=0)
+
+    assert np.all(depth.min(dim="range_sample") >= pelagic_upper)
+    assert np.all(depth.max(dim="range_sample") <= pelagic_lower)
+
+    bottom_depth = echodata["Platform"]["bottom_depth"]
+    bottom_upper = ds_cal["bottom_upper"].isel(channel=0)
+    bottom_lower = ds_cal["bottom_lower"].isel(channel=0)
+    depth_bottom = ds_cal["depth_bottom"].isel(channel=0)
+
+    window_start = bottom_depth - bottom_upper
+    window_stop = bottom_depth - bottom_lower
+
+    assert np.all(depth_bottom.min(dim="range_sample_bottom") >= window_start)
+    assert np.all(depth_bottom.max(dim="range_sample_bottom") <= window_stop)
+
+
+def test_bi500_single_targets(bi500_output):
+    """Verify BI500 single-target products and ping linkage."""
+    _, ds_cal = bi500_output
+
+    assert ds_cal.sizes["single_target"] == 8724
+
+    required_target_variables = [
+        "single_target_identifier",
+        "ping_index",
+        "single_target_ping_time",
+        "single_target_depth",
+        "single_target_alongship_angle",
+        "single_target_athwartship_angle",
+        "uncompensated_TS",
+        "compensated_TS",
+    ]
+
+    for variable in required_target_variables:
+        assert variable in ds_cal
+        assert ds_cal[variable].dims == ("single_target",)
+        assert ds_cal[variable].shape == (8724,)
+
+    assert np.isfinite(ds_cal["single_target_depth"].values).any()
+    assert np.isfinite(ds_cal["uncompensated_TS"].values).any()
+    assert np.isfinite(ds_cal["compensated_TS"].values).any()
+
+    assert ds_cal["single_target_depth"].attrs["units"] == "m"
+    assert ds_cal["single_target_depth"].attrs["positive"] == "down"
+    assert ds_cal["single_target_alongship_angle"].attrs["units"] == "arc_degree"
+    assert ds_cal["single_target_athwartship_angle"].attrs["units"] == "arc_degree"
+    assert ds_cal["uncompensated_TS"].attrs["units"] == "dB"
+    assert ds_cal["compensated_TS"].attrs["units"] == "dB"
+
+    ping_index = ds_cal["ping_index"].values
+
+    assert np.issubdtype(ping_index.dtype, np.integer)
+    assert ping_index.min() >= 0
+    assert ping_index.max() < ds_cal.sizes["ping_time"]
+
+    np.testing.assert_array_equal(
+        ds_cal["single_target_ping_time"].values,
+        ds_cal["ping_time"].values[ping_index],
+    )
+
+def test_bi500_calibrated_structure(bi500_output):
+    """BI500 calibrated output follows the standard Sv dimensional structure."""
+    _, ds_cal = bi500_output
+
+    assert ds_cal["Sv"].dims == (
+        "channel",
+        "ping_time",
+        "range_sample",
+    )
+    assert ds_cal["depth"].dims == ds_cal["Sv"].dims
+
+    assert ds_cal["frequency_nominal"].dims == ("channel",)
+
+    # BI500 provides absolute depth, not transducer-relative range
+    assert "echo_range" not in ds_cal
+
+def test_bi500_groups_multiple_channels_from_one_acquisition():
+    """Verify BI500 companion files are grouped by frequency/transceiver."""
+    parser = ParseBI500.__new__(ParseBI500)
+
+    prefix = "N031-S445-S2000008"
+    acquisition = "D20000921-T034142"
+    channel_sets = [
+        ("011990", "01"),
+        ("037879", "02"),
+        ("119048", "03"),
+    ]
+
+    files = [
+        f"/tmp/{prefix}-F{frequency}-T{transceiver}-{acquisition}{file_type}"
+        for frequency, transceiver in channel_sets
+        for file_type in ("-Data", "-Info", "-Ping")
+    ]
+
+    parser._group_file_sets(files)
+
+    assert parser.acquisition_key == (prefix, "20000921", "034142")
+    assert len(parser.file_set_map) == 3
+
+    for frequency, transceiver in channel_sets:
+        file_type_map = parser.file_set_map[(frequency, transceiver)]
+        assert set(file_type_map) == {"-Data", "-Info", "-Ping"}
+
+
+def test_bi500_rejects_multiple_acquisitions():
+    """Verify one open_raw BI500 input cannot mix acquisition periods."""
+    parser = ParseBI500.__new__(ParseBI500)
+
+    files = [
+        "/tmp/N031-S445-S2000008-F011990-T01-D20000921-T034142-Data",
+        "/tmp/N031-S445-S2000008-F011990-T01-D20000921-T034142-Info",
+        "/tmp/N031-S445-S2000008-F011990-T01-D20000921-T034142-Ping",
+        "/tmp/N031-S445-S2000008-F037879-T02-D20000922-T034142-Data",
+        "/tmp/N031-S445-S2000008-F037879-T02-D20000922-T034142-Info",
+        "/tmp/N031-S445-S2000008-F037879-T02-D20000922-T034142-Ping",
+    ]
+
+    with pytest.raises(ValueError, match="single acquisition"):
+        parser._group_file_sets(files)
\ No newline at end of file
diff --git a/echopype/utils/prov.py b/echopype/utils/prov.py
index 60e233f7e..4e0c4daa8 100644
--- a/echopype/utils/prov.py
+++ b/echopype/utils/prov.py
@@ -240,7 +240,10 @@ def inner(self, *args, **kwargs):
             def inner(*args, **kwargs):
                 dataobj = func(*args, **kwargs)
                 if is_echodata:
-                    ed = dataobj
+                    # Most functions return a single EchoData object.
+                    # BI500 open_raw returns (echodata, ds_cal).
+                    ed = dataobj[0] if isinstance(dataobj, tuple) else dataobj
+
                     if _check_valid_latlon(ed["Platform"]):
                         # The decorator is passed the exact, final level code, with sublevel
                         processing_level = PROCESSING_LEVELS[processing_level_code]
@@ -254,7 +257,8 @@ def inner(*args, **kwargs):
                             "will not be added."
                         )
 
-                    return ed
+                    # Return the original output so BI500 keeps both echodata and ds_cal.
+                    return dataobj
                 elif isinstance(dataobj, xr.Dataset):
                     ds = dataobj
                     if _check_valid_latlon(ds):