Skip to main content

Python Pandas: How to Fix Datetime Errors: "NaTType does not support strftime" and "DateParseError"

Converting columns to datetime objects is a fundamental operation in Pandas when dealing with time-series data. However, this process can sometimes lead to errors like ValueError: NaTType does not support strftime or pandas._libs.tslibs.parsing.DateParseError: day is out of range for month. These errors typically indicate problems with how date strings are being parsed, often due to invalid date formats, incorrect parsing logic, or attempting operations on NaT (Not a Time) values.

This guide will dissect these common datetime conversion errors, explain their root causes, and provide robust solutions using pd.to_datetime() with appropriate error handling and format specification, ensuring you can reliably convert your string columns to datetime objects.

Understanding Pandas Datetime Conversion and NaT​

Pandas' pd.to_datetime() function is the primary tool for converting strings, integers, or other array-like objects into Pandas datetime64[ns] objects. When pd.to_datetime() encounters a value it can not parse into a valid date (e.g., "2025-02-31" or "not-a-date"), its behavior is governed by the errors parameter:

  • errors='raise' (default): Raises an error (like DateParseError or ValueError).
  • errors='coerce': Invalid parsing will be set as NaT (Not a Time). NaT is Pandas' equivalent of NaN for datetime objects.
  • errors='ignore': Invalid parsing will return the input as is.

Error 1: ValueError: NaTType does not support strftime​

This error occurs when you attempt to call the .strftime() method (which formats a datetime object into a string) on a NaT value. NaT represents a missing or invalid datetime, and thus, it doesn't have a date/time structure to format.

Reproducing the Error: Applying strftime After Coercing Invalid Dates (Often in a Loop or Apply)​

A common mistake is to iterate over date strings, convert each individually with errors='coerce', and then immediately try to format it, without checking if the conversion resulted in NaT.

import pandas as pd

df = pd.DataFrame({
    'event_date_str': ['2025-01-15', '2025-02-30', '2025-03-10'] # '2025-02-30' is invalid
})

formatted_dates_error = []
try:
    for date_str in df['event_date_str']:
        # pd.to_datetime for '2025-02-30' with errors='coerce' becomes NaT
        dt_object = pd.to_datetime(date_str, errors='coerce')
        # ⛔️ When dt_object is NaT, NaT.strftime('%Y-%m-%d') raises the error
        formatted_dates_error.append(dt_object.strftime('%Y-%m-%d'))
except ValueError as e:
    print(f"Error: {e}")

Output:

ERROR!
Error: NaTType does not support strftime

The Cause: strftime Can not Operate on NaT​

The loop processes '2025-02-30'. pd.to_datetime('2025-02-30', errors='coerce') returns NaT. Then, NaT.strftime('%Y-%m-%d') is called, triggering the error.

Solution: Vectorized Conversion with pd.to_datetime().dt.strftime()​

The best practice is to apply pd.to_datetime() to the entire Series (column) at once. This is vectorized and efficient. Then, use the .dt accessor to apply strftime to the resulting datetime Series. The .dt.strftime() method correctly handles NaT values, typically converting them to NaN or None in the resulting string Series.

import pandas as pd

df = pd.DataFrame({
    'event_date_str': ['2025-01-15', '2025-02-30', '2025-03-10', None]
})

# ✅ Convert the entire column first, then format
# Step 1: Convert to datetime objects (invalid dates become NaT)
df['event_datetime'] = pd.to_datetime(df['event_date_str'], errors='coerce')
print("DataFrame after pd.to_datetime():")
print(df)
print()

# Step 2: Format the datetime column to string (NaT becomes NaN/None in string column)
df['formatted_date_str'] = df['event_datetime'].dt.strftime('%Y-%m-%d')
print("DataFrame with formatted date strings:")
print(df)
print()

# You can do this in one line if you are overwriting or creating a new column:
df['event_date_str_formatted_direct'] = pd.to_datetime(
    df['event_date_str'],
    errors='coerce'
).dt.strftime('%Y-%m-%d')
print("Directly formatted column:")
print(df[['event_date_str', 'event_date_str_formatted_direct']])

Output:

DataFrame after pd.to_datetime():
  event_date_str event_datetime
0     2025-01-15     2025-01-15
1     2025-02-30            NaT
2     2025-03-10     2025-03-10
3           None            NaT

DataFrame with formatted date strings:
  event_date_str event_datetime formatted_date_str
0     2025-01-15     2025-01-15         2025-01-15
1     2025-02-30            NaT                NaN
2     2025-03-10     2025-03-10         2025-03-10
3           None            NaT                NaN

Directly formatted column:
  event_date_str event_date_str_formatted_direct
0     2025-01-15                      2025-01-15
1     2025-02-30                             NaN
2     2025-03-10                      2025-03-10
3           None                             NaN
note

Avoid iterating or using .apply() for simple to_datetime conversions followed by strftime on a whole column; vectorized operations are preferred.

Error 2: DateParseError: day is out of range for month (and similar parsing issues)​

This error, or variations like OutOfBoundsDatetime, ValueError: month must be in 1..12, occurs when pd.to_datetime() (with errors='raise' by default, or if a format string is too strict) encounters a date string that is structurally a date but has an invalid value (e.g., day 31 in February).

Reproducing the Error: Invalid Date Values​

If errors='raise' (the default), pd.to_datetime() will fail on invalid dates. This also happens if .apply(lambda x: pd.to_datetime(x)) is used, as each x is processed individually.

import pandas as pd

df_invalid = pd.DataFrame({
    'date_str': ['2025-01-25', '2025-02-31', '2025-04-01']  # '2025-02-31' is invalid
})

try:
    # ⛔ This will raise an error due to the invalid date
    df_invalid['parsed_date'] = pd.to_datetime(df_invalid['date_str'])  # errors='raise' is default
    print(df_invalid)
except ValueError as e:  # Catch the correct exception type
    print(f"❌ Error during date parsing:\n{e}")

Output:

❌ Error during date parsing:
day is out of range for month, at position 1. You might want to try:
    - passing `format` if your strings have a consistent format;
    - passing `format='ISO8601'` if your strings are all ISO8601 but not necessarily in exactly the same format;
    - passing `format='mixed'`, and the format will be inferred for each element individually. You might want to use `dayfirst` alongside this.

Solution: Using errors='coerce' with pd.to_datetime()​

errors='coerce' is the key. It converts unparseable or invalid dates to NaT instead of raising an error.

import pandas as pd

df_invalid = pd.DataFrame({
    'date_str': ['2025-01-25', '2025-02-31', '2025-04-01']  # '2025-02-31' is invalid
})

# ✅ Coerce invalid dates to NaT
df_invalid['parsed_date_coerced'] = pd.to_datetime(df_invalid['date_str'], errors='coerce')

print("DataFrame with invalid dates coerced to NaT:")
print(df_invalid)

Output:

DataFrame with invalid dates coerced to NaT:
     date_str parsed_date_coerced
0  2025-01-25          2025-01-25
1  2025-02-31                 NaT
2  2025-04-01          2025-04-01

Handling Day-First Formats with dayfirst=True​

If your date strings are in DD-MM-YYYY or DD/MM/YYYY format, Pandas might misinterpret them as MM-DD-YYYY if the day part is <= 12. Use dayfirst=True to guide the parser.

import pandas as pd

df_dayfirst = pd.DataFrame({
    'date_uk_format': ['25-01-2025', '10-02-2025', '31-03-2025', '15-13-2025'] # 15-13-2025 is invalid
})

# ✅ Parse with dayfirst=True
df_dayfirst['parsed_date'] = pd.to_datetime(
    df_dayfirst['date_uk_format'],
    errors='coerce',
    dayfirst=True
)
print("Parsing day-first format:")
print(df_dayfirst)

Output:

Parsing day-first format:
  date_uk_format parsed_date
0     25-01-2025  2025-01-25
1     10-02-2025  2025-02-10
2     31-03-2025  2025-03-31
3     15-13-2025         NaT

Specifying the Exact Date Format with the format Argument​

If your date strings have a consistent, known format, providing the format argument to pd.to_datetime() is the most reliable way to parse them. This can also be faster.

import pandas as pd

df_custom_format = pd.DataFrame({
    'event_timestamp': ['2025/25/01 10:30', '2025/31/02 11:45', '2025/01/03 12:00'] # Format: YYYY/DD/MM HH:MM
})

# ✅ Specify the exact format
df_custom_format['parsed_timestamp'] = pd.to_datetime(
    df_custom_format['event_timestamp'],
    format='%Y/%d/%m %H:%M', # Matches the YYYY/DD/MM HH:MM structure
    errors='coerce'
)
print("Parsing with a specific format string:")
print(df_custom_format)

Output:

Parsing with a specific format string:
    event_timestamp    parsed_timestamp
0  2025/25/01 10:30 2025-01-25 10:30:00
1  2025/31/02 11:45                 NaT
2  2025/01/03 12:00 2025-03-01 12:00:00

Using format implicitly tells Pandas the order of day, month, year, so dayfirst might not be needed if format is unambiguous.

Best Practices for Datetime Conversion​

  • Vectorize: Always try to use pd.to_datetime() on the entire Series/column rather than iterating or using .apply() for simple conversions.
  • Handle Errors: Use errors='coerce' to turn unparseable/invalid dates into NaT, which you can then handle (e.g., fill, drop, or investigate).
  • Be Format-Aware: If your dates are not in the standard ISO 8601 format (YYYY-MM-DD), use dayfirst=True for DD-MM-YYYY or provide an explicit format string for unambiguous parsing.
  • Post-Conversion Formatting: If you need to format the datetime objects back into strings (e.g., for display or output), do this after the successful conversion to datetime objects using Series.dt.strftime('%Y-%m-%d'). This correctly handles NaT values by typically turning them into NaN in the string output.

Conclusion​

Errors like ValueError: NaTType does not support strftime and DateParseError in Pandas are common when working with date strings. The key to resolving them lies in:

  1. Using the vectorized pd.to_datetime(your_series, errors='coerce', ...) to handle potential invalid date strings by converting them to NaT.
  2. Applying string formatting (.dt.strftime()) after the entire Series has been converted to datetime objects, as .dt.strftime() can gracefully handle NaT values.
  3. Providing hints to the parser like dayfirst=True or an explicit format string if your date formats are non-standard. By following these practices, you can build robust pipelines for datetime conversion in Pandas.

Table of Contents