diff --git a/climada/hazard/test/test_tc_tracks.py b/climada/hazard/test/test_tc_tracks.py
index f1943c7f3..ced0dc1c7 100644
--- a/climada/hazard/test/test_tc_tracks.py
+++ b/climada/hazard/test/test_tc_tracks.py
@@ -1341,7 +1341,7 @@ def test_track_land_params(self):
         lon_test = np.array([170, 179.18, 180.05])
         lat_test = np.array([-60, -16.56, -16.85])
         on_land = np.array([False, True, True])
-        lon_shift = np.array([-360, 0, 360])
+        lon_shift = np.array([360, 360, 360])
         # ensure both points are considered on land as is
         np.testing.assert_array_equal(
             u_coord.coord_on_land(lat=lat_test, lon=lon_test), on_land
diff --git a/climada/hazard/trop_cyclone/trop_cyclone_windfields.py b/climada/hazard/trop_cyclone/trop_cyclone_windfields.py
index f8ac09078..ac77e0f43 100644
--- a/climada/hazard/trop_cyclone/trop_cyclone_windfields.py
+++ b/climada/hazard/trop_cyclone/trop_cyclone_windfields.py
@@ -902,6 +902,15 @@ def _coriolis_parameter(lat: np.ndarray) -> np.ndarray:
     cp : np.ndarray of same shape as input
         Coriolis parameter.
     """
+    if not u_coord.check_if_geo_coords(lat, 0):
+        raise ValueError(
+            "Input lat and lon coordinates do not seem to correspond"
+            " to geographic coordinates in degrees. This can be because"
+            " total extents are > 180 for lat or > 360 for lon, lat coordinates"
+            " are outside of -90<lat<90, or lon coordinates are outside of -540<lon<540."
+            " If you use degree values outside of these ranges,"
+            " please shift the coordinates to the valid ranges."
+        )
     return 2 * V_ANG_EARTH * np.sin(np.radians(np.abs(lat)))
 
 
diff --git a/climada/util/coordinates.py b/climada/util/coordinates.py
index 5b2a72cf6..5ef7d8ca9 100644
--- a/climada/util/coordinates.py
+++ b/climada/util/coordinates.py
@@ -85,6 +85,66 @@
 are not considered."""
 
 
+def check_if_geo_coords(lat, lon):
+    """Check if latitude and longitude arrays are likely in geographic coordinates,
+    testing if min/max values are within -90 to 90 for latitude and -540 to 540
+    for longitude. Lon coordinates of <-360 or >360 are allowed to cover cases
+    of objects being defined close to the 180 meridian.
+
+    Parameters
+    ----------
+    lat, lon : ndarrays of floats, same shape
+        Latitudes and longitudes of points.
+
+    Returns
+    -------
+    test : bool
+        True if lat/lon ranges seem to be in the geographic coordinates range, otherwise False.
+    """
+    lat = np.array(lat)
+    lon = np.array(lon)
+
+    # Check if latitude is within -90 to 90 and longitude is within -540 to 540
+    # and extent are smaller than 180 and 360 respectively
+    test = (
+        lat.min() >= -91 and lat.max() <= 91 and lon.min() >= -541 and lon.max() <= 541
+    ) and ((lat.max() - lat.min()) <= 181 and (lon.max() - lon.min()) <= 361)
+    return bool(test)
+
+
+def infer_unit_coords(coords):
+    """
+    Infer the unit of measurement for the given coordinate system.
+
+    Parameters
+    ----------
+    coords : GeoDataFrame or similar object
+        An object with a coordinate reference system (CRS) attribute.
+
+    Returns
+    -------
+    unit : str
+        The unit of measurement for the coordinate system, either 'degree' for
+        geodetic systems or 'm' for projected systems.
+
+    Raises
+    ------
+    ValueError
+        If the coordinate system is neither geodetic nor projected, or if the
+        unit cannot be inferred.
+    """
+
+    if coords.crs.is_geographic:
+        unit = "degree"
+    elif coords.crs.is_projected:
+        unit = "m"
+    else:
+        raise ValueError(
+            "Unable to infer unit for coordinate points. Please specify unit of the coordinates."
+        )
+    return unit
+
+
 def latlon_to_geosph_vector(lat, lon, rad=False, basis=False):
     """Convert lat/lon coodinates to radial vectors (on geosphere)
 
@@ -448,13 +508,26 @@ def get_gridcellarea(lat, resolution=0.5, unit="ha"):
     unit: string, optional
         unit of the output area (default: ha, alternatives: m2, km2)
     """
-
+    # first check that lat is in geographic coordinates
+    if not check_if_geo_coords(lat, 0):
+        raise ValueError(
+            "Input lat and lon coordinates do not seem to correspond"
+            " to geographic coordinates in degrees. This can be because"
+            " total extents are > 180 for lat or > 360 for lon, lat coordinates"
+            " are outside of -90<lat<90, or lon coordinates are outside of -540<lon<540."
+            " If you use degree values outside of these ranges,"
+            " please shift the coordinates to the valid ranges."
+        )
     if unit == "m2":
         area = (ONE_LAT_KM * resolution) ** 2 * np.cos(np.deg2rad(lat)) * 1000000
     elif unit == "km2":
         area = (ONE_LAT_KM * resolution) ** 2 * np.cos(np.deg2rad(lat))
-    else:
+    elif unit == "ha":
         area = (ONE_LAT_KM * resolution) ** 2 * np.cos(np.deg2rad(lat)) * 100
+    else:
+        raise ValueError(
+            f"'{unit}' unit not recognized. Please use any of 'm2', 'km2' or 'ha'."
+        )
 
     return area
 
@@ -507,6 +580,15 @@ def convert_wgs_to_utm(lon, lat):
     epsg_code : int
         EPSG code of UTM projection.
     """
+    if not check_if_geo_coords(lat, lon):
+        raise ValueError(
+            "Input lat and lon coordinates do not seem to correspond"
+            " to geographic coordinates in degrees. This can be because"
+            " total extents are > 180 for lat or > 360 for lon, lat coordinates"
+            " are outside of -90<lat<90, or lon coordinates are outside of -540<lon<540."
+            " If you use degree values outside of these ranges,"
+            " please shift the coordinates to the valid ranges."
+        )
     epsg_utm_base = 32601 + (0 if lat >= 0 else 100)
     return epsg_utm_base + (math.floor((lon + 180) / 6) % 60)
 
@@ -564,6 +646,15 @@ def dist_to_coast(coord_lat, lon=None, highres=False, signed=False):
             raise ValueError(
                 f"Mismatching input coordinates size: {lat.size} != {lon.size}"
             )
+    if not check_if_geo_coords(lat, lon):
+        raise ValueError(
+            "Input lat and lon coordinates do not seem to correspond"
+            " to geographic coordinates in degrees. This can be because"
+            " total extents are > 180 for lat or > 360 for lon, lat coordinates"
+            " are outside of -90<lat<90, or lon coordinates are outside of -540<lon<540."
+            " If you use degree values outside of these ranges,"
+            " please shift the coordinates to the valid ranges."
+        )
     return dist_to_coast_nasa(lat, lon, highres=highres, signed=signed)
 
 
@@ -679,6 +770,15 @@ def coord_on_land(lat, lon, land_geom=None):
         )
     if lat.size == 0:
         return np.empty((0,), dtype=bool)
+    if not check_if_geo_coords(lat, lon):
+        raise ValueError(
+            "Input lat and lon coordinates do not seem to correspond"
+            " to geographic coordinates in degrees. This can be because"
+            " total extents are > 180 for lat or > 360 for lon, lat coordinates"
+            " are outside of -90<lat<90, or lon coordinates are outside of -540<lon<540."
+            " If you use degree values outside of these ranges,"
+            " please shift the coordinates to the valid ranges."
+        )
     delta_deg = 1
     lons = lon.copy()
     if land_geom is None:
@@ -796,9 +896,14 @@ def get_country_geometries(
         out = out[country_mask]
 
     if extent:
-        if extent[1] - extent[0] > 360:
+        if not check_if_geo_coords(extent[2:], extent[:2]):
             raise ValueError(
-                f"longitude extent range is greater than 360: {extent[0]} to {extent[1]}"
+                "Input lat and lon coordinates do not seem to correspond"
+                " to geographic coordinates in degrees. This can be because"
+                " total extents are > 180 for lat or > 360 for lon, lat coordinates"
+                " are outside of -90<lat<90, or lon coordinates are outside of -540<lon<540."
+                " If you use degree values outside of these ranges,"
+                " please shift the coordinates to the valid ranges."
             )
 
         if extent[1] < extent[0]:
@@ -986,6 +1091,7 @@ def match_coordinates(
     coords,
     coords_to_assign,
     distance="euclidean",
+    unit="degree",
     threshold=NEAREST_NEIGHBOR_THRESHOLD,
     **kwargs,
 ):
@@ -1016,6 +1122,9 @@ def match_coordinates(
     distance : str, optional
         Distance to use for non-exact matching. Possible values are "euclidean", "haversine" and
         "approx". Default: "euclidean"
+    unit : str, optional
+        Unit to use for non-exact matching. Possible values are "degree", "m", "km".
+        Default: "degree"
     threshold : float, optional
         If the distance to the nearest neighbor exceeds `threshold`, the index `-1` is assigned.
         Set `threshold` to 0 to disable nearest neighbor matching. Default: 100 (km)
@@ -1089,15 +1198,51 @@ def match_coordinates(
 
         # assign remaining coordinates to their geographically nearest neighbor
         if threshold > 0 and exact_assign_idx.size != coords_view.size:
+            # convert to proper units before proceeding to nearest neighbor search
+            if unit == "degree":
+                # check that coords are indeed geographic before converting
+                if not (
+                    check_if_geo_coords(coords[:, 0], coords[:, 1])
+                    and check_if_geo_coords(
+                        coords_to_assign[:, 0], coords_to_assign[:, 1]
+                    )
+                ):
+                    raise ValueError(
+                        "Input lat and lon coordinates do not seem to correspond"
+                        " to geographic coordinates in degrees. This can be because"
+                        " total extents are > 180 for lat or > 360 for lon, lat coordinates"
+                        " are outside of -90<lat<90, or lon coordinates are outside of "
+                        "-540<lon<540. If you use degree values outside of these ranges,"
+                        " please shift the coordinates to the valid ranges."
+                    )
+
+                coords = np.radians(coords)
+                coords_to_assign = np.radians(coords_to_assign)
+            elif unit == "m":
+                coords *= 1e-3
+                coords_to_assign *= 1e-3
+            elif unit == "km":
+                pass
+            else:
+                raise ValueError("Unit must be one of 'degree', 'm' or 'km'.")
+
             not_assigned_idx_mask = assigned_idx == -1
             assigned_idx[not_assigned_idx_mask] = nearest_neighbor_funcs[distance](
-                coords_to_assign, coords[not_assigned_idx_mask], threshold, **kwargs
+                coords_to_assign,
+                coords[not_assigned_idx_mask],
+                unit,
+                threshold,
+                **kwargs,
             )
     return assigned_idx
 
 
 def match_centroids(
-    coord_gdf, centroids, distance="euclidean", threshold=NEAREST_NEIGHBOR_THRESHOLD
+    coord_gdf,
+    centroids,
+    distance="euclidean",
+    unit=None,
+    threshold=NEAREST_NEIGHBOR_THRESHOLD,
 ):
     """Assign to each gdf coordinate point its closest centroids's coordinate.
     If distances > threshold in points' distances, -1 is returned.
@@ -1113,6 +1258,9 @@ def match_centroids(
         Distance to use in case of vector centroids.
         Possible values are "euclidean", "haversine" and "approx".
         Default: "euclidean"
+    unit : str, optional
+        Unit to use for non-exact matching. Possible values are "degree", "m", "km".
+        Default: None
     threshold : float, optional
         If the distance (in km) to the nearest neighbor exceeds `threshold`,
         the index `-1` is assigned.
@@ -1151,10 +1299,15 @@ def match_centroids(
         # no error is raised and it is assumed that the user set the crs correctly
         pass
 
+    # infer unit
+    if not unit:
+        unit = infer_unit_coords(coord_gdf)
+
     assigned = match_coordinates(
         np.stack([coord_gdf.geometry.y.values, coord_gdf.geometry.x.values], axis=1),
         centroids.coord,
         distance=distance,
+        unit=unit,
         threshold=threshold,
     )
     return assigned
@@ -1170,7 +1323,7 @@ def _dist_sqr_approx(lats1, lons1, cos_lats1, lats2, lons2):
 
 
 def _nearest_neighbor_approx(
-    centroids, coordinates, threshold, check_antimeridian=True
+    centroids, coordinates, unit, threshold, check_antimeridian=True
 ):
     """Compute the nearest centroid for each coordinate using the
     euclidean distance d = ((dlon)cos(lat))^2+(dlat)^2. For distant points
@@ -1184,6 +1337,8 @@ def _nearest_neighbor_approx(
     coordinates : 2d array
         First column contains latitude, second
         column contains longitude. Each row is a geographic point
+    unit : str
+        Unit to use for non-exact matching. Only possible value is "degree"
     threshold : float
         distance threshold in km over which no neighbor will
         be found. Those are assigned with a -1 index
@@ -1198,14 +1353,22 @@ def _nearest_neighbor_approx(
     np.array
         with as many rows as coordinates containing the centroids indexes
     """
-
+    # first check that unit is in degree
+    if unit != "degree":
+        raise ValueError(
+            "Only degree unit is supported for nearest neighbor approximation."
+            "Please use euclidean distance for non-degree units."
+        )
     # Compute only for the unique coordinates. Copy the results for the
     # not unique coordinates
     _, idx, inv = np.unique(coordinates, axis=0, return_index=True, return_inverse=True)
     # Compute cos(lat) for all centroids
-    centr_cos_lat = np.cos(np.radians(centroids[:, 0]))
+    centr_cos_lat = np.cos(centroids[:, 0])
     assigned = np.zeros(coordinates.shape[0], int)
     num_warn = 0
+    # need to convert back to degrees for the approx distance and nearest neighbor
+    coordinates = np.rad2deg(coordinates)
+    centroids = np.rad2deg(centroids)
     for icoord, iidx in enumerate(idx):
         dist = _dist_sqr_approx(
             centroids[:, 0],
@@ -1239,7 +1402,7 @@ def _nearest_neighbor_approx(
     return assigned
 
 
-def _nearest_neighbor_haversine(centroids, coordinates, threshold):
+def _nearest_neighbor_haversine(centroids, coordinates, unit, threshold):
     """Compute the neareast centroid for each coordinate using a Ball tree with haversine distance.
 
     Parameters
@@ -1250,6 +1413,8 @@ def _nearest_neighbor_haversine(centroids, coordinates, threshold):
     coordinates : 2d array
         First column contains latitude, second
         column contains longitude. Each row is a geographic point
+    unit : str
+        Unit to use for non-exact matching. Only possible value is "degree"
     threshold : float
         distance threshold in km over which no neighbor will
         be found. Those are assigned with a -1 index
@@ -1259,14 +1424,20 @@ def _nearest_neighbor_haversine(centroids, coordinates, threshold):
     np.array
         with as many rows as coordinates containing the centroids indexes
     """
+    # first check that unit is in degree
+    if unit != "degree":
+        raise ValueError(
+            "Only degree unit is supported for nearest neighbor approximation."
+            "Please use euclidean distance for non-degree units."
+        )
     # Construct tree from centroids
-    tree = BallTree(np.radians(centroids), metric="haversine")
+    tree = BallTree(centroids, metric="haversine")
     # Select unique exposures coordinates
     _, idx, inv = np.unique(coordinates, axis=0, return_index=True, return_inverse=True)
 
     # query the k closest points of the n_points using dual tree
     dist, assigned = tree.query(
-        np.radians(coordinates[idx]),
+        coordinates[idx],
         k=1,
         return_distance=True,
         dualtree=True,
@@ -1279,21 +1450,20 @@ def _nearest_neighbor_haversine(centroids, coordinates, threshold):
 
     # Raise a warning if the minimum distance is greater than the
     # threshold and set an unvalid index -1
-    num_warn = np.sum(dist * EARTH_RADIUS_KM > threshold)
+    dist = dist * EARTH_RADIUS_KM
+    num_warn = np.sum(dist > threshold)
     if num_warn:
         LOGGER.warning(
-            "Distance to closest centroid is greater than %s" "km for %s coordinates.",
-            threshold,
-            num_warn,
+            f"Distance to closest centroid is greater than {threshold} km for {num_warn} coordinates."
         )
-        assigned[dist * EARTH_RADIUS_KM > threshold] = -1
+        assigned[dist > threshold] = -1
 
     # Copy result to all exposures and return value
     return assigned[inv]
 
 
 def _nearest_neighbor_euclidean(
-    centroids, coordinates, threshold, check_antimeridian=True
+    centroids, coordinates, unit, threshold, check_antimeridian=True
 ):
     """Compute the neareast centroid for each coordinate using a k-d tree.
 
@@ -1305,6 +1475,8 @@ def _nearest_neighbor_euclidean(
     coordinates : 2d array
         First column contains latitude, second column contains longitude. Each
         row is a geographic point
+    unit : str
+        Unit to use for non-exact matching. Possible values are "degree", "m", "km".
     threshold : float
         distance threshold in km over which no neighbor will be found. Those
         are assigned with a -1 index
@@ -1312,6 +1484,7 @@ def _nearest_neighbor_euclidean(
         If True, the nearest neighbor in a strip with lon size equal to threshold around the
         antimeridian is recomputed using the Haversine distance. The antimeridian is guessed from
         both coordinates and centroids, and is assumed equal to 0.5*(lon_max+lon_min) + 180.
+        Requires the coordinates to be in degrees.
         Default: True
 
     Returns
@@ -1320,27 +1493,30 @@ def _nearest_neighbor_euclidean(
         with as many rows as coordinates containing the centroids indexes
     """
     # Construct tree from centroids
-    tree = scipy.spatial.KDTree(np.radians(centroids))
+    tree = scipy.spatial.KDTree(centroids)
     # Select unique exposures coordinates
     _, idx, inv = np.unique(coordinates, axis=0, return_index=True, return_inverse=True)
 
     # query the k closest points of the n_points using dual tree
-    dist, assigned = tree.query(np.radians(coordinates[idx]), k=1, p=2, workers=-1)
+    dist, assigned = tree.query(coordinates[idx], k=1, p=2, workers=-1)
 
     # Raise a warning if the minimum distance is greater than the
     # threshold and set an unvalid index -1
-    num_warn = np.sum(dist * EARTH_RADIUS_KM > threshold)
+    if unit == "degree":
+        dist = dist * EARTH_RADIUS_KM
+    else:
+        # if unit is not in degree, check_antimeridian is forced to False
+        check_antimeridian = False
+    num_warn = np.sum(dist > threshold)
     if num_warn:
         LOGGER.warning(
-            "Distance to closest centroid is greater than %s" "km for %s coordinates.",
-            threshold,
-            num_warn,
+            f"Distance to closest centroid is greater than {threshold} km for {num_warn} coordinates."
         )
-        assigned[dist * EARTH_RADIUS_KM > threshold] = -1
+        assigned[dist > threshold] = -1
 
     if check_antimeridian:
         assigned = _nearest_neighbor_antimeridian(
-            centroids, coordinates[idx], threshold, assigned
+            np.rad2deg(centroids), np.rad2deg(coordinates[idx]), threshold, assigned
         )
 
     # Copy result to all exposures and return value
@@ -1389,7 +1565,7 @@ def _nearest_neighbor_antimeridian(centroids, coordinates, threshold, assigned):
         if np.any(cent_strip_bool):
             cent_strip = centroids[cent_strip_bool]
             strip_assigned = _nearest_neighbor_haversine(
-                cent_strip, coord_strip, threshold
+                np.deg2rad(cent_strip), np.deg2rad(coord_strip), "degree", threshold
             )
             new_coords = cent_strip_bool.nonzero()[0][strip_assigned]
             new_coords[strip_assigned == -1] = -1
@@ -1595,6 +1771,16 @@ def get_country_code(lat, lon, gridded=False):
     if lat.size == 0:
         return np.empty((0,), dtype=int)
     LOGGER.info("Setting region_id %s points.", str(lat.size))
+    # first check that input lat lon are geographic
+    if not check_if_geo_coords(lat, lon):
+        raise ValueError(
+            "Input lat and lon coordinates do not seem to correspond"
+            " to geographic coordinates in degrees. This can be because"
+            " total extents are > 180 for lat or > 360 for lon, lat coordinates"
+            " are outside of -90<lat<90, or lon coordinates are outside of -540<lon<540."
+            " If you use degree values outside of these ranges,"
+            " please shift the coordinates to the valid ranges."
+        )
     if gridded:
         base_file = u_hdf5.read(NATEARTH_CENTROIDS[150])
         meta, region_id = base_file["meta"], base_file["region_id"]
diff --git a/climada/util/test/test_coordinates.py b/climada/util/test/test_coordinates.py
index 56ba3af91..5b44136ff 100644
--- a/climada/util/test/test_coordinates.py
+++ b/climada/util/test/test_coordinates.py
@@ -38,7 +38,13 @@
 import climada.util.coordinates as u_coord
 from climada import CONFIG
 from climada.hazard.base import Centroids
-from climada.util.constants import DEF_CRS, DEMO_DIR, HAZ_DEMO_FL, ONE_LAT_KM
+from climada.util.constants import (
+    DEF_CRS,
+    DEMO_DIR,
+    EARTH_RADIUS_KM,
+    HAZ_DEMO_FL,
+    ONE_LAT_KM,
+)
 
 DATA_DIR = CONFIG.util.test_data.dir()
 
@@ -230,6 +236,53 @@ def def_ref_50():
     )
 
 
+class TestInferUnitCoords(unittest.TestCase):
+    def create_mock_gdf(self, crs, num_points=5):
+        geometry = [
+            shapely.Point(x, y) for x, y in zip(range(num_points), range(num_points))
+        ]
+        gdf = gpd.GeoDataFrame(geometry=geometry, crs=crs)
+        return gdf
+
+    def test_infer_unit_geodetic(self):
+        """Test with a geodetic CRS (EPSG:4326)."""
+        crs = "EPSG:4326"
+        gdf = self.create_mock_gdf(crs)
+        unit = u_coord.infer_unit_coords(gdf)
+        self.assertEqual(unit, "degree", "Expected unit 'degree' for geodetic CRS.")
+
+    def test_infer_unit_projected(self):
+        """Test with a projected CRS (EPSG:3857)."""
+        crs = "EPSG:3857"
+        gdf = self.create_mock_gdf(crs)
+        unit = u_coord.infer_unit_coords(gdf)
+        self.assertEqual(unit, "m", "Expected unit 'm' for projected CRS.")
+
+    def test_infer_unit_undefined_crs(self):
+        """Test with an undefined CRS."""
+        crs = None
+        gdf = self.create_mock_gdf(crs)
+        with self.assertRaises(AttributeError):
+            u_coord.infer_unit_coords(gdf)
+
+    def test_infer_unit_unsupported_crs(self):
+        """Test with a mocked unsupported CRS."""
+
+        class MockCRS:
+            is_geographic = False
+            is_projected = False
+
+        class MockGDF:
+            crs = MockCRS()
+
+        mock_gdf = MockGDF()
+        with self.assertRaises(ValueError) as context:
+            u_coord.infer_unit_coords(mock_gdf)
+        self.assertIn(
+            "Unable to infer unit for coordinate points", str(context.exception)
+        )
+
+
 class TestDistance(unittest.TestCase):
     """Test distance functions."""
 
@@ -342,6 +395,23 @@ def data_arrays_resampling_demo():
 class TestFunc(unittest.TestCase):
     """Test auxiliary functions"""
 
+    def test_check_geo_coords(self):
+        """Test the check_if_geo_coords function"""
+        # test correct geographical coords
+        lat, lon = np.array([0, -2, 5]), np.array([-179, 175, 178])
+        self.assertEqual(u_coord.check_if_geo_coords(lat, lon), True)
+        # test wrong lat
+        lat, lon = np.array([0, 200, 5]), np.array([-179, 175, 178])
+        self.assertEqual(u_coord.check_if_geo_coords(lat, lon), False)
+        # test wrong lon
+        lat, lon = np.array([0, -2, 5]), np.array([-400, 175, 176])
+        self.assertEqual(u_coord.check_if_geo_coords(lat, lon), False)
+        lat, lon = np.array([0, -2, 5]), np.array([700, 1000, 800])
+        self.assertEqual(u_coord.check_if_geo_coords(lat, lon), False)
+        # test wrong extent
+        lat, lon = np.array([0, -2, 5]), np.array([-179, 175, 370])
+        self.assertEqual(u_coord.check_if_geo_coords(lat, lon), False)
+
     def test_lon_normalize(self):
         """Test the longitude normalization function"""
         data = np.array([-180, 20.1, -30, 190, -350])
@@ -1255,30 +1325,52 @@ def test_diff_outcomes(self):
             )
             np.testing.assert_array_equal(neighbors, ref)
 
-    def test_match_coordinates(self):
-        """Test match_coordinates function"""
-        # note that the coordinates are in lat/lon
-        coords = np.array(
+    def setUp_match_coordinates(self):
+        # Set up mock data for tests
+        # note that the base coordinates are in lat/lon
+        self.coords = np.array(
             [(0.2, 2), (0, 0), (0, 2), (2.1, 3), (1, 1), (-1, 1), (0, 179.9)]
         )
-        coords_to_assign = np.array([(2.1, 3), (0, 0), (0, 2), (0.9, 1.0), (0, -179.9)])
-        expected_results = [
-            # test with different thresholds (in km)
-            (100, [2, 1, 2, 0, 3, -1, 4]),
-            (20, [-1, 1, 2, 0, 3, -1, -1]),
-            (0, [-1, 1, 2, 0, -1, -1, -1]),
-        ]
+        self.coords_to_assign = np.array(
+            [(2.1, 3), (0, 0), (0, 2), (0.9, 1.0), (0, -179.9)]
+        )
+        # test with different unit
+        self.expected_results = {
+            "degree": [
+                # test with different thresholds (in km)
+                (100, [2, 1, 2, 0, 3, -1, 4]),
+                (20, [-1, 1, 2, 0, 3, -1, -1]),
+                (0, [-1, 1, 2, 0, -1, -1, -1]),
+            ],
+            "m": [
+                # test with different thresholds (in km)
+                (100, [2, 1, 2, 0, 3, -1, -1]),
+                (20, [-1, 1, 2, 0, 3, -1, -1]),
+                (0, [-1, 1, 2, 0, -1, -1, -1]),
+            ],
+            "km": [
+                # test with different thresholds (in km)
+                (100, [2, 1, 2, 0, 3, -1, -1]),
+                (20, [-1, 1, 2, 0, 3, -1, -1]),
+                (0, [-1, 1, 2, 0, -1, -1, -1]),
+            ],
+        }
 
+    def test_match_coordinates(self):
+        """Test match_coordinates function"""
+        self.setUp_match_coordinates()
+        unit = "degree"  # first only check for degrees
         for distance in ["euclidean", "haversine", "approx"]:
             # make sure that it works for both float32 and float64
             for test_dtype in [np.float64, np.float32]:
-                coords_typed = coords.astype(test_dtype)
-                coords_to_assign_typed = coords_to_assign.astype(test_dtype)
-                for thresh, result in expected_results:
+                coords_typed = self.coords.astype(test_dtype)
+                coords_to_assign_typed = self.coords_to_assign.astype(test_dtype)
+                for thresh, result in self.expected_results[unit]:
                     assigned_idx = u_coord.match_coordinates(
                         coords_typed,
                         coords_to_assign_typed,
                         distance=distance,
+                        unit=unit,
                         threshold=thresh,
                     )
                     np.testing.assert_array_equal(assigned_idx, result)
@@ -1287,7 +1379,7 @@ def test_match_coordinates(self):
             coords_to_assign_empty = np.array([])
             result = [-1, -1, -1, -1, -1, -1, -1]
             assigned_idx = u_coord.match_coordinates(
-                coords, coords_to_assign_empty, distance=distance, threshold=thresh
+                self.coords, coords_to_assign_empty, distance=distance, threshold=thresh
             )
             np.testing.assert_array_equal(assigned_idx, result)
 
@@ -1295,10 +1387,92 @@ def test_match_coordinates(self):
             coords_empty = np.array([])
             result = np.array([])
             assigned_idx = u_coord.match_coordinates(
-                coords_empty, coords_to_assign, distance=distance, threshold=thresh
+                coords_empty, self.coords_to_assign, distance=distance, threshold=thresh
             )
             np.testing.assert_array_equal(assigned_idx, result)
 
+    def test_match_coordinates_different_unit(self):
+        """Test match_coordinates function in cases of different units"""
+        self.setUp_match_coordinates()
+        unit_conv_funcs = {
+            "degree": lambda x: x,
+            "km": lambda x: np.deg2rad(x) * EARTH_RADIUS_KM,
+            "m": lambda x: np.deg2rad(x) * EARTH_RADIUS_KM * 1e3,
+        }
+        distance = "euclidean"
+        for unit in ["degree", "km", "m"]:
+            results = self.expected_results[unit]
+            # do not check antimeridian if units are not in degree
+            check_antimeridian = False if unit != "degree" else True
+            # make sure that it works for both float32 and float64
+            for test_dtype in [np.float64, np.float32]:
+                coords_typed = unit_conv_funcs[unit](self.coords.astype(test_dtype))
+                coords_to_assign_typed = unit_conv_funcs[unit](
+                    self.coords_to_assign.astype(test_dtype)
+                )
+                for thresh, result in results:
+                    assigned_idx = u_coord.match_coordinates(
+                        coords_typed,
+                        coords_to_assign_typed,
+                        distance=distance,
+                        unit=unit,
+                        threshold=thresh,
+                        check_antimeridian=check_antimeridian,
+                    )
+                    np.testing.assert_array_equal(assigned_idx, result)
+            # test empty coords_to_assign
+            coords_to_assign_empty = np.array([])
+            result = [-1, -1, -1, -1, -1, -1, -1]
+            assigned_idx = u_coord.match_coordinates(
+                self.coords,
+                coords_to_assign_empty,
+                distance=distance,
+                unit=unit,
+                threshold=thresh,
+            )
+            np.testing.assert_array_equal(assigned_idx, result)
+            # test empty coords
+            coords_empty = np.array([])
+            result = np.array([])
+            assigned_idx = u_coord.match_coordinates(
+                coords_empty,
+                self.coords_to_assign,
+                distance=distance,
+                unit=unit,
+                threshold=thresh,
+            )
+            np.testing.assert_array_equal(assigned_idx, result)
+
+    def test_match_coordinates_invalid_unit(self):
+        """Test match_coordinates with invalid unit"""
+        self.setUp_match_coordinates()
+        coords_to_assign = np.deg2rad(self.coords_to_assign)
+        coords = np.deg2rad(self.coords)
+        with self.assertRaises(ValueError):
+            u_coord.match_coordinates(
+                coords, coords_to_assign, "foo", u_coord.NEAREST_NEIGHBOR_THRESHOLD
+            )
+
+    def test_nearest_neighbor_approx_invalid_unit(self):
+        """Test approx nearest neighbor with invalid unit"""
+        self.setUp_match_coordinates()
+        coords_to_assign = np.deg2rad(self.coords_to_assign)
+        coords = np.deg2rad(self.coords)
+        with self.assertRaises(ValueError):
+            u_coord._nearest_neighbor_approx(
+                coords_to_assign, coords, "km", u_coord.NEAREST_NEIGHBOR_THRESHOLD
+            )
+
+    def test_nearest_neighbor_haversine_invalid_unit(self):
+        """Test haversine nearest neighbor with invalid unit"""
+        self.setUp_match_coordinates()
+        coords_to_assign = np.deg2rad(self.coords_to_assign)
+        coords = np.deg2rad(self.coords)
+        with self.assertRaises(ValueError):
+            u_coord._nearest_neighbor_haversine(
+                coords_to_assign, coords, "km", u_coord.NEAREST_NEIGHBOR_THRESHOLD
+            )
+
 
 class TestGetGeodata(unittest.TestCase):
     def test_nat_earth_resolution_pass(self):
@@ -1457,18 +1631,10 @@ def test_get_country_geometries_all_pass(self):
 
     def test_get_country_geometries_fail(self):
         """get_country_geometries with offensive parameters"""
-        with self.assertRaises(ValueError) as cm:
+        with self.assertRaises(ValueError):
             u_coord.get_country_geometries(extent=(-20, 350, 0, 0))
-        self.assertIn(
-            "longitude extent range is greater than 360: -20 to 350", str(cm.exception)
-        )
-        with self.assertRaises(ValueError) as cm:
-            u_coord.get_country_geometries(extent=(350, -20, 0, 0))
-        self.assertIn(
-            "longitude extent at the left (350) is larger "
-            "than longitude extent at the right (-20)",
-            str(cm.exception),
-        )
+        with self.assertRaises(ValueError):
+            u_coord.get_country_geometries(extent=(340, -20, 0, 0))
 
     def test_country_code_pass(self):
         """Test set_region_id"""