@@ -47,6 +47,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 - Fixed the `rec-details` tool returning an error instead of AWS Compute Optimizer details for RDS recommendations. It called `get_rds_instance_recommendations`, which does not exist in boto3; it now calls `get_rds_database_recommendations` with `resourceArns`.
 - Fixed the `compute-optimizer-automation` tool rejecting `start_time`/`end_time` values that end in the ISO 8601 UTC designator `Z` (e.g. `2026-07-10T00:00:00Z`). A single trailing `Z` is now accepted; the values were already interpreted as UTC.
+- Fixed timestamp formatting in the `rec-details` tool and Cost Optimization Hub responses. `rec-details` divided boto3 `datetime` values by 1000, so every `last_refresh_timestamp` became an error string; Cost Optimization Hub treated every number as epoch milliseconds (placing epoch seconds in January 1970) and rendered it in local time. Both now use a shared formatter that accepts `datetime`, epoch seconds, and epoch milliseconds and returns a UTC ISO 8601 string, or `null` (with a logged warning) instead of an error string when a value cannot be converted.
 - Fixed pagination metadata reporting more pages when an AWS API returns an empty-string pagination token on its last page. Some APIs (e.g. Savings Plans `DescribeSavingsPlansOfferingRates`) return `nextToken: ""` rather than omitting it, which made `paginate_aws_response` report `has_more: true`, `complete_dataset: false`, and `next_token: ""` even though all pages had been fetched. The metadata now treats any falsy token as no more pages (`has_more: false`, `complete_dataset: true`, `next_token: null`). A non-empty token returned when the `max_pages` limit is reached still reports `has_more: true` with that token. The `get_credit_allocation_history` and `get_savings_plans_purchase_recommendation` tools, which build their own pagination metadata instead of using `paginate_aws_response`, carried the same bug and are fixed the same way.
 - Fixed `get_savings_plans_utilization` returning "No Savings Plans utilization data found" on every call (#3351). It read `SavingsPlansUtilizations` where the API returns `SavingsPlansUtilizationsByTime`, and behind that early return the figures were read from each row's top level as `{Amount, Unit}` mappings, but the API nests them under `Utilization`, `Savings` and `AmortizedCommitment` as decimal strings. Rows and `Total` now pass through as the API sends them, preserving decimal precision and the previously discarded blocks
 - Fixed `get_savings_plans_utilization_details` reporting every plan's utilization and savings as zero, from the same two causes. Rows now pass through as the API sends them, including the previously discarded `AmortizedCommitment` block and the whole of `Attributes` -- superseding the `summary` block, which read lowercase keys the API does not send, and exposing the owning `AccountId`
 
@@ -37,40 +37,23 @@
 )
 from ..utilities.logging_utils import get_context_logger
 from ..utilities.sql_utils import convert_response_if_needed
+from ..utilities.time_utils import format_timestamp_to_utc_iso
 from botocore.exceptions import ClientError
-from datetime import datetime
 from fastmcp import Context
 from typing import Any, Dict, Optional
 
 
 def format_timestamp(timestamp: Any) -> Optional[str]:
-    """Format a timestamp to ISO format string.
+    """Format a timestamp to a UTC ISO 8601 string.
 
     Args:
-        timestamp: Timestamp from Cost Optimization Hub API
+        timestamp: Timestamp from Cost Optimization Hub API: a datetime (boto3),
+            epoch seconds, or epoch milliseconds.
 
     Returns:
-        Formatted timestamp string
+        Formatted timestamp string, or None if missing or unconvertible.
     """
-    if not timestamp:
-        return None
-
-    try:
-        # Check if it's already a datetime object
-        if isinstance(timestamp, datetime):
-            return timestamp.isoformat()
-        else:
-            # Assume it's a Unix timestamp in milliseconds
-            from datetime import timezone
-
-            return (
-                datetime.fromtimestamp(timestamp / 1000, tz=timezone.utc)
-                .astimezone()
-                .replace(tzinfo=None)
-                .isoformat()
-            )
-    except Exception as e:
-        return str(f'Error: {e}, Timestamp: {timestamp}')
+    return format_timestamp_to_utc_iso(timestamp)
 
 
 async def list_recommendations(
 
@@ -37,7 +37,7 @@
     SERVICE_MAP,
     TERM_MAP,
 )
-from datetime import datetime
+from ..utilities.time_utils import format_timestamp_to_utc_iso
 from fastmcp import Context, FastMCP
 from typing import Any, Dict, Optional
 
@@ -382,15 +382,9 @@ async def get_compute_optimizer_data(
         return {'error': f'Error getting Compute Optimizer data: {str(e)}'}
 
 
-def format_timestamp(timestamp: Optional[int]) -> Optional[str]:
-    """Format Unix timestamp to ISO format string."""
-    if timestamp is None:
-        return None
-
-    try:
-        return datetime.fromtimestamp(timestamp / 1000).isoformat()
-    except Exception as e:
-        return str(f'Error: {e}, Timestamp: {timestamp}')  # Return as string if conversion fails
+def format_timestamp(timestamp: Any) -> Optional[str]:
+    """Format a COH timestamp (datetime, epoch seconds or epoch ms) as a UTC ISO string."""
+    return format_timestamp_to_utc_iso(timestamp)
 
 
 def get_template_for_recommendation(
 
@@ -14,8 +14,12 @@
 
 """Time utility functions for the AWS Billing and Cost Management MCP server."""
 
+from .logging_utils import get_logger
 from datetime import datetime, timezone
-from typing import Any, Union
+from typing import Any, Optional, Union
+
+
+logger = get_logger(__name__)
 
 
 # Supported UTC datetime formats, ordered from most specific to least specific.
@@ -70,6 +74,66 @@ def timestamp_to_utc_iso_string(timestamp: Union[int, float, datetime]) -> str:
     return datetime.fromtimestamp(timestamp, tz=timezone.utc).replace(tzinfo=None).isoformat()
 
 
+# An epoch value above this is in milliseconds: read as seconds it would fall after
+# the year 5000, while read as milliseconds it falls after March 1973.
+EPOCH_MILLISECONDS_THRESHOLD = 1e11
+
+
+def format_timestamp_to_utc_iso(timestamp: Any) -> Optional[str]:
+    """Format an AWS timestamp of any wire form as a UTC ISO 8601 string.
+
+    The same field arrives in different forms depending on the client: boto3
+    deserializes timestamps into ``datetime`` objects, while JSON callers see epoch
+    seconds or, for some services, epoch milliseconds. Accepts:
+
+    - ``datetime`` (naive values are taken as UTC; aware values are converted)
+    - epoch seconds (int/float)
+    - epoch milliseconds (int/float above ``EPOCH_MILLISECONDS_THRESHOLD``)
+    - strings holding any of the above numbers, or an ISO 8601 datetime
+
+    Args:
+        timestamp: The timestamp value, or None.
+
+    Returns:
+        ISO 8601 UTC string without offset (e.g. "2023-11-14T22:13:20"), or None when
+        the value is missing or cannot be converted. Conversion failures are logged,
+        never written into the returned value.
+    """
+    if timestamp is None:
+        return None
+
+    value = timestamp
+    if isinstance(value, str):
+        value = _parse_timestamp_string(value)
+
+    try:
+        if isinstance(value, datetime):
+            return timestamp_to_utc_iso_string(value)
+        if isinstance(value, (int, float)) and not isinstance(value, bool):
+            seconds = value / 1000 if abs(value) > EPOCH_MILLISECONDS_THRESHOLD else value
+            return timestamp_to_utc_iso_string(seconds)
+    except (OverflowError, OSError, ValueError):
+        pass
+
+    logger.warning(
+        f'Could not convert timestamp of type {type(timestamp).__name__}; returning None'
+    )
+    return None
+
+
+def _parse_timestamp_string(text: str) -> Any:
+    """Parse a timestamp string into a number or datetime; return None if neither."""
+    stripped = text.strip()
+    try:
+        return float(stripped)
+    except ValueError:
+        pass
+    try:
+        return datetime.fromisoformat(stripped.replace('Z', '+00:00'))
+    except ValueError:
+        return None
+
+
 def normalize_datetimes_to_iso(obj: Any) -> Any:
     """Recursively convert ``datetime`` values in a structure to ISO 8601 UTC strings.
 
 
@@ -158,6 +158,25 @@ def test_format_timestamp_with_none(self):
         result = format_timestamp(None)
         assert result is None
 
+    def test_format_timestamp_with_epoch_seconds(self):
+        """Epoch seconds are read as seconds, not milliseconds (no 1970 dates)."""
+        assert format_timestamp(1756728000) == '2025-09-01T12:00:00'
+
+    def test_format_timestamp_with_epoch_milliseconds(self):
+        """Epoch milliseconds are still supported."""
+        assert format_timestamp(1756728000000) == '2025-09-01T12:00:00'
+
+    def test_format_timestamp_with_aware_datetime(self):
+        """An aware datetime is normalized to UTC."""
+        from datetime import timezone
+
+        value = datetime(2025, 9, 1, 12, 0, tzinfo=timezone.utc)
+        assert format_timestamp(value) == '2025-09-01T12:00:00'
+
+    def test_format_timestamp_unconvertible_returns_none(self):
+        """Unconvertible input yields None, never an error string."""
+        assert format_timestamp('garbage') is None
+
 
 @pytest.mark.asyncio
 class TestListRecommendations:
@@ -1930,6 +1949,26 @@ async def test_no_params_calls_api_without_arguments(self, mock_context):
             }
         ]
 
+    @pytest.mark.asyncio
+    async def test_epoch_second_timestamps_are_not_1970(self, mock_context):
+        """JSON callers send epoch seconds; enrollment dates must not land in 1970."""
+        client = MagicMock()
+        client.list_enrollment_statuses.return_value = {
+            'items': [
+                {
+                    **self._ITEM,
+                    'lastUpdatedTimestamp': 1788264000,
+                    'createdTimestamp': 1735689600.0,
+                }
+            ]
+        }
+
+        result = await list_enrollment_statuses(mock_context, client)
+
+        (entry,) = result['data']['enrollment_statuses']
+        assert entry['last_updated_timestamp'] == '2026-09-01T12:00:00'
+        assert entry['created_timestamp'] == '2025-01-01T00:00:00'
+
     @pytest.mark.asyncio
     async def test_account_id_forwarded(self, mock_context):
         """account_id maps to the API's accountId."""
 
@@ -35,6 +35,7 @@
     process_recommendation,
     recommendation_details_server,
 )
+from datetime import datetime, timezone
 from fastmcp import Context
 from unittest.mock import AsyncMock, MagicMock, mock_open, patch
 
@@ -334,18 +335,37 @@ def mock_compute_optimizer_client():
 
 def test_format_timestamp():
     """Test format_timestamp function."""
-    # Test with a valid timestamp
-    timestamp = 1632825600000
-    result = format_timestamp(timestamp)
-    assert result and '2021-09-28' in result
+    # Epoch milliseconds
+    assert format_timestamp(1632825600000) == '2021-09-28T10:40:00'
 
     # Test with None
-    result = format_timestamp(None)
-    assert result is None
+    assert format_timestamp(None) is None
 
-    # Test with invalid timestamp
-    result = format_timestamp(None)
-    assert result is None
+
+def test_format_timestamp_accepts_boto3_datetime():
+    """boto3 returns datetime; it must format, not fail on datetime / int."""
+    assert format_timestamp(datetime(2021, 9, 28, 10, 40)) == '2021-09-28T10:40:00'
+
+
+def test_format_timestamp_accepts_epoch_seconds():
+    """Epoch seconds (AWS JSON wire form) are not divided by 1000 into 1970."""
+    assert format_timestamp(1632825600) == '2021-09-28T10:40:00'
+
+
+def test_format_timestamp_never_returns_error_text():
+    """An unconvertible value yields None rather than an 'Error: ...' string."""
+    assert format_timestamp(object()) is None
+
+
+def test_format_base_recommendation_with_boto3_datetime():
+    """The rec-details last_refresh_timestamp is a real timestamp for boto3 input."""
+    result = format_base_recommendation(
+        {
+            'recommendationId': 'rec-1',
+            'lastRefreshTimestamp': datetime(2026, 9, 1, 12, 0, tzinfo=timezone.utc),
+        }
+    )
+    assert result['last_refresh_timestamp'] == '2026-09-01T12:00:00'
 
 
 def test_format_base_recommendation():
 
@@ -16,10 +16,13 @@
 
 import pytest
 from awslabs.billing_cost_management_mcp_server.utilities.time_utils import (
+    EPOCH_MILLISECONDS_THRESHOLD,
+    format_timestamp_to_utc_iso,
     normalize_datetimes_to_iso,
     timestamp_to_utc_iso_string,
 )
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
+from unittest.mock import patch
 
 
 class TestUtcDatetimeStringToEpochSeconds:
@@ -153,3 +156,68 @@ def test_scalar_passthrough(self):
         assert normalize_datetimes_to_iso('hello') == 'hello'
         assert normalize_datetimes_to_iso(42) == 42
         assert normalize_datetimes_to_iso(None) is None
+
+
+class TestFormatTimestampToUtcIso:
+    """Tests for format_timestamp_to_utc_iso (datetime, epoch seconds, epoch ms)."""
+
+    # 2021-09-28T10:40:00Z in each wire form.
+    EXPECTED = '2021-09-28T10:40:00'
+    EPOCH_SECONDS = 1632825600
+    EPOCH_MS = 1632825600000
+
+    def test_none_returns_none(self):
+        """A missing timestamp is None, not an error string."""
+        assert format_timestamp_to_utc_iso(None) is None
+
+    def test_naive_datetime_is_taken_as_utc(self):
+        """boto3-style naive datetime is formatted as-is (UTC)."""
+        assert format_timestamp_to_utc_iso(datetime(2021, 9, 28, 10, 40)) == self.EXPECTED
+
+    def test_aware_datetime_is_converted_to_utc(self):
+        """An aware datetime in another zone is converted to UTC."""
+        eastern = timezone(timedelta(hours=-4))
+        value = datetime(2021, 9, 28, 6, 40, tzinfo=eastern)
+        assert format_timestamp_to_utc_iso(value) == self.EXPECTED
+
+    def test_epoch_seconds(self):
+        """Epoch seconds (the AWS JSON wire form) are not divided by 1000."""
+        assert format_timestamp_to_utc_iso(self.EPOCH_SECONDS) == self.EXPECTED
+
+    def test_epoch_seconds_float(self):
+        """Fractional epoch seconds keep their sub-second part."""
+        assert format_timestamp_to_utc_iso(1632825600.5) == '2021-09-28T10:40:00.500000'
+
+    def test_epoch_milliseconds(self):
+        """Epoch milliseconds are recognized by magnitude."""
+        assert format_timestamp_to_utc_iso(self.EPOCH_MS) == self.EXPECTED
+
+    def test_threshold_boundary(self):
+        """Values at the threshold are seconds; values above are milliseconds."""
+        at = format_timestamp_to_utc_iso(EPOCH_MILLISECONDS_THRESHOLD)
+        assert at is not None and at.startswith('5138-')
+        above = format_timestamp_to_utc_iso(EPOCH_MILLISECONDS_THRESHOLD + 1)
+        assert above is not None and above.startswith('1973-')
+
+    def test_epoch_zero_is_a_value(self):
+        """Epoch 0 is a real instant, not a missing value."""
+        assert format_timestamp_to_utc_iso(0) == '1970-01-01T00:00:00'
+
+    @pytest.mark.parametrize(
+        'value',
+        ['1632825600', '1632825600000', '2021-09-28T10:40:00Z', '2021-09-28T10:40:00+00:00'],
+    )
+    def test_strings(self, value):
+        """Numeric and ISO 8601 strings are accepted."""
+        assert format_timestamp_to_utc_iso(value) == self.EXPECTED
+
+    @pytest.mark.parametrize(
+        'value', ['not a timestamp', '', True, float('nan'), float('inf'), 1e20, [1], {}]
+    )
+    def test_unconvertible_returns_none_and_logs(self, value):
+        """Unconvertible input returns None and logs; no error text in the value."""
+        with patch(
+            'awslabs.billing_cost_management_mcp_server.utilities.time_utils.logger'
+        ) as mock_logger:
+            assert format_timestamp_to_utc_iso(value) is None
+        mock_logger.warning.assert_called_once()