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..2e2916cf2 100644
--- a/climada/util/coordinates.py
+++ b/climada/util/coordinates.py
@@ -85,6 +85,65 @@
 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 for which longitude
+    intervals such as [179, 538] or [-538, -179] might be used.
+
+    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 get_crs_unit(coords):
+    """
+    Retrieve the unit of measurement for the coordinate reference system (CRS).
+
+    Parameters
+    ----------
+    coords : GeoDataFrame
+        An object with a coordinate reference system (CRS) attribute.
+
+    Returns
+    -------
+    unit : str
+        The unit of measurement for the coordinate system, as specified in the
+        CRS axis information. Assumes that both axes have the same unit.
+    """
+
+    unit = coords.crs.axis_info[0].unit_name  # assume both axes have the same unit
+    if unit == "degree":
+        pass
+    elif unit == "metre":
+        unit = "m"
+    elif unit == "kilometre":
+        unit = "km"
+    else:
+        raise ValueError(
+            f"Unknown unit: {unit}. Please provide a crs that has a unit "
+            "of 'degree', 'metre' or 'kilometre'."
+        )
+    return unit
+
+
 def latlon_to_geosph_vector(lat, lon, rad=False, basis=False):
     """Convert lat/lon coodinates to radial vectors (on geosphere)
 
@@ -448,13 +507,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 +579,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 +645,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 +769,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 +895,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 +1090,7 @@ def match_coordinates(
     coords,
     coords_to_assign,
     distance="euclidean",
+    unit="degree",
     threshold=NEAREST_NEIGHBOR_THRESHOLD,
     **kwargs,
 ):
@@ -1016,6 +1121,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 +1197,48 @@ 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."
+                    )
+
+            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",
+    threshold=NEAREST_NEIGHBOR_THRESHOLD,
 ):
     """Assign to each gdf coordinate point its closest centroids's coordinate.
     If distances > threshold in points' distances, -1 is returned.
@@ -1146,15 +1287,25 @@ def match_centroids(
     try:
         if not equal_crs(coord_gdf.crs, centroids.crs):
             raise ValueError("Set hazard and GeoDataFrame to same CRS first!")
-    except AttributeError:
-        # If the coord_gdf has no crs defined (or no valid geometry column),
-        # no error is raised and it is assumed that the user set the crs correctly
-        pass
+        if coord_gdf.crs is None or centroids.crs is None:
+            raise ValueError(
+                "Please provide coordinate GeoDataFrame and Hazard "
+                "object with a valid crs attribute."
+            )
+    except AttributeError as exc:
+        # a crs attribute is needed for unit inference
+        raise ValueError(
+            "Please provide coordinate GeoDataFrame and Hazard object with a valid crs attribute."
+        ) from exc
+
+    # get unit of coordinate systems from axis of crs
+    unit = get_crs_unit(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 +1321,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 +1335,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,7 +1351,12 @@ 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)
@@ -1239,7 +1397,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 +1408,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,6 +1419,12 @@ 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")
     # Select unique exposures coordinates
@@ -1279,21 +1445,22 @@ 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.",
+            "Distance to closest centroid is greater than %i km for %i coordinates.",
             threshold,
             num_warn,
         )
-        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 +1472,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 +1481,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
@@ -1319,24 +1489,38 @@ def _nearest_neighbor_euclidean(
     np.array
         with as many rows as coordinates containing the centroids indexes
     """
+    if (
+        unit == "degree"
+    ):  # if unit is in degree convert to radians for dist calculations
+        centroids = np.radians(centroids)
+        coordinates = np.radians(coordinates)
     # 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)
+
+    if unit == "degree":
+        # convert back to degree for check antimeridian and convert distance
+        centroids = np.rad2deg(centroids)
+        coordinates = np.rad2deg(coordinates)
+        dist = dist * EARTH_RADIUS_KM
+    else:
+        # if unit is not in degree, check_antimeridian is forced to False
+        check_antimeridian = False
 
     # 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)
+    num_warn = np.sum(dist > threshold)
     if num_warn:
         LOGGER.warning(
-            "Distance to closest centroid is greater than %s" "km for %s coordinates.",
+            "Distance to closest centroid is greater than %i km for %i coordinates.",
             threshold,
             num_warn,
         )
-        assigned[dist * EARTH_RADIUS_KM > threshold] = -1
+        assigned[dist > threshold] = -1
 
     if check_antimeridian:
         assigned = _nearest_neighbor_antimeridian(
@@ -1389,7 +1573,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
+                cent_strip, coord_strip, "degree", threshold
             )
             new_coords = cent_strip_bool.nonzero()[0][strip_assigned]
             new_coords[strip_assigned == -1] = -1
@@ -1595,6 +1779,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..4bef1718a 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,47 @@ def def_ref_50():
     )
 
 
+class TestGetUnitCoords(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_get_unit_degree(self):
+        """Test with a geodetic CRS in degree (EPSG:4326)."""
+        crs = "EPSG:4326"
+        gdf = self.create_mock_gdf(crs)
+        unit = u_coord.get_crs_unit(gdf)
+        self.assertEqual(unit, "degree", "Expected unit 'degree' for geodetic CRS.")
+
+    def test_get_unit_projected_m(self):
+        """Test with a projected CRS in m (EPSG:3857)."""
+        crs = "EPSG:3857"
+        gdf = self.create_mock_gdf(crs)
+        unit = u_coord.get_crs_unit(gdf)
+        self.assertEqual(unit, "m", "Expected unit 'm' for projected CRS.")
+
+    def test_get_unit_projected_km(self):
+        """Test with a projected CRS in km (EPSG:22300)."""
+        crs = "EPSG:22300"
+        gdf = self.create_mock_gdf(crs)
+        unit = u_coord.get_crs_unit(gdf)
+        self.assertEqual(unit, "km", "Expected unit 'km' for projected CRS.")
+
+    def test_get_unit_invalid_crs(self):
+        """Test with an invalid CRS."""
+        crs = "EPSG:8189"
+        gdf = self.create_mock_gdf(crs)
+        with self.assertRaises(ValueError) as cm:
+            u_coord.get_crs_unit(gdf)
+            self.assertIn(
+                "Unknown unit: US survey foot. Please provide a crs that has a unit of 'degree', 'metre' or 'kilometre'.",
+                str(cm.exception),
+            )
+
+
 class TestDistance(unittest.TestCase):
     """Test distance functions."""
 
@@ -342,6 +389,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])
@@ -420,7 +484,7 @@ def test_dist_approx_pass(self):
                 [-3, -130.1, 4, -30.5, 11079.7217421, 11087.0352544],
             ]
         )
-        # conversion factors from reference data (in km, see above) to other units
+        # conversion factors from reference data (in km see above) to other units
         factors_km_to_x = {
             "m": 1e3,
             "radian": np.radians(1.0) / u_coord.ONE_LAT_KM,
@@ -490,7 +554,7 @@ def test_dist_approx_log_pass(self):
                 [24.0, 85.0, 24.0, 85.0, 0, 0],
             ]
         )
-        # conversion factors from reference data (in km, see above) to other units
+        # conversion factors from reference data (in km see above) to other units
         factors_km_to_x = {
             "m": 1e3,
             "radian": np.radians(1.0) / u_coord.ONE_LAT_KM,
@@ -883,6 +947,25 @@ def test_match_centroids(self):
             "Set hazard and GeoDataFrame to same CRS first!", str(cm.exception)
         )
 
+        # Test 4: no crs
+        df = pd.DataFrame({"longitude": [10, 20, 30], "latitude": [50, 60, 70]})
+        gdf = gpd.GeoDataFrame(
+            df,
+            geometry=gpd.points_from_xy(df["longitude"], df["latitude"]),
+            crs=None,
+        )
+
+        coords_to_assign = np.array([(2.1, 3), (0, 0), (0, 2), (0.9, 1.0), (0, -179.9)])
+        centroids = Centroids(lat=[1100000, 1200000], lon=[2500000, 2600000], crs=None)
+
+        with self.assertRaises(ValueError) as cm:
+            u_coord.match_centroids(gdf, centroids)
+        self.assertIn(
+            "Please provide coordinate GeoDataFrame and "
+            "Hazard object with a valid crs attribute.",
+            str(cm.exception),
+        )
+
     def test_dist_sqr_approx_pass(self):
         """Test approximate distance helper function."""
         lats1 = 45.5
@@ -1255,30 +1338,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 degree)
+                (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 m)
+                (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 +1392,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 +1400,98 @@ 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 +1650,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"""