diff --git a/homeassistant/components/tesla_fleet/coordinator.py b/homeassistant/components/tesla_fleet/coordinator.py
index 129f460ff90..128c15068f6 100644
--- a/homeassistant/components/tesla_fleet/coordinator.py
+++ b/homeassistant/components/tesla_fleet/coordinator.py
@@ -17,7 +17,6 @@ from tesla_fleet_api.exceptions import (
     TeslaFleetError,
     VehicleOffline,
 )
-from tesla_fleet_api.ratecalculator import RateCalculator
 
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
@@ -66,7 +65,6 @@ class TeslaFleetVehicleDataCoordinator(DataUpdateCoordinator[dict[str, Any]]):
     updated_once: bool
     pre2021: bool
     last_active: datetime
-    rate: RateCalculator
 
     def __init__(
         self,
@@ -87,44 +85,36 @@ class TeslaFleetVehicleDataCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         self.data = flatten(product)
         self.updated_once = False
         self.last_active = datetime.now()
-        self.rate = RateCalculator(100, 86400, VEHICLE_INTERVAL_SECONDS, 3600, 5)
 
     async def _async_update_data(self) -> dict[str, Any]:
         """Update vehicle data using TeslaFleet API."""
 
         try:
-            # Check if the vehicle is awake using a non-rate limited API call
-            if self.data["state"] != TeslaFleetState.ONLINE:
-                response = await self.api.vehicle()
-                self.data["state"] = response["response"]["state"]
+            # Check if the vehicle is awake using a free API call
+            response = await self.api.vehicle()
+            self.data["state"] = response["response"]["state"]
 
             if self.data["state"] != TeslaFleetState.ONLINE:
                 return self.data
 
-            # This is a rated limited API call
-            self.rate.consume()
             response = await self.api.vehicle_data(endpoints=ENDPOINTS)
             data = response["response"]
 
         except VehicleOffline:
             self.data["state"] = TeslaFleetState.ASLEEP
             return self.data
-        except RateLimited as e:
+        except RateLimited:
             LOGGER.warning(
-                "%s rate limited, will retry in %s seconds",
+                "%s rate limited, will skip refresh",
                 self.name,
-                e.data.get("after"),
             )
-            if "after" in e.data:
-                self.update_interval = timedelta(seconds=int(e.data["after"]))
             return self.data
         except (InvalidToken, OAuthExpired, LoginRequired) as e:
             raise ConfigEntryAuthFailed from e
         except TeslaFleetError as e:
             raise UpdateFailed(e.message) from e
 
-        # Calculate ideal refresh interval
-        self.update_interval = timedelta(seconds=self.rate.calculate())
+        self.update_interval = VEHICLE_INTERVAL
 
         self.updated_once = True
 
diff --git a/tests/components/tesla_fleet/test_init.py b/tests/components/tesla_fleet/test_init.py
index 2162226efb0..ff103ce03c2 100644
--- a/tests/components/tesla_fleet/test_init.py
+++ b/tests/components/tesla_fleet/test_init.py
@@ -156,14 +156,15 @@ async def test_vehicle_refresh_offline(
     mock_vehicle_state.reset_mock()
     mock_vehicle_data.reset_mock()
 
-    # Then the vehicle goes offline
+    # Then the vehicle goes offline despite saying its online
     mock_vehicle_data.side_effect = VehicleOffline
     freezer.tick(VEHICLE_INTERVAL)
     async_fire_time_changed(hass)
     await hass.async_block_till_done()
 
-    mock_vehicle_state.assert_not_called()
+    mock_vehicle_state.assert_called_once()
     mock_vehicle_data.assert_called_once()
+    mock_vehicle_state.reset_mock()
     mock_vehicle_data.reset_mock()
 
     # And stays offline
@@ -212,20 +213,15 @@ async def test_vehicle_refresh_ratelimited(
 
     assert (state := hass.states.get("sensor.test_battery_level"))
     assert state.state == "unknown"
-    assert mock_vehicle_data.call_count == 1
+
+    mock_vehicle_data.reset_mock()
 
     freezer.tick(VEHICLE_INTERVAL)
     async_fire_time_changed(hass)
     await hass.async_block_till_done()
 
-    # Should not call for another 10 seconds
-    assert mock_vehicle_data.call_count == 1
-
-    freezer.tick(VEHICLE_INTERVAL)
-    async_fire_time_changed(hass)
-    await hass.async_block_till_done()
-
-    assert mock_vehicle_data.call_count == 2
+    assert (state := hass.states.get("sensor.test_battery_level"))
+    assert state.state == "unknown"
 
 
 async def test_vehicle_sleep(