Introduction

In pandas, converting a timedelta column to integers is mainly a question of unit choice. A duration can become seconds, minutes, hours, or days, and the correct conversion depends on what downstream code expects. Once the unit is explicit, the transformation is simple and vectorized.

Start With a Timedelta Column

A timedelta column often comes from subtracting one timestamp column from another.

1import pandas as pd
2
3df = pd.DataFrame({
4    "start": pd.to_datetime(["2026-01-01 10:00:00", "2026-01-01 10:05:00"]),
5    "end": pd.to_datetime(["2026-01-01 10:03:30", "2026-01-01 10:16:30"]),
6})
7
8df["delta"] = df["end"] - df["start"]
9print(df)

At this point, df["delta"] is a pandas timedelta dtype, not an integer column.

Convert to Integer Seconds

The clearest path is .dt.total_seconds(), then a cast after you decide how to handle fractions.

1df["seconds_float"] = df["delta"].dt.total_seconds()
2df["seconds_int"] = df["seconds_float"].round().astype("int64")
3
4print(df[["delta", "seconds_int"]])

The important design choice is rounding. In some workflows you want round, in others floor, ceil, or truncation.

Convert to Minutes, Hours, or Days

Other units are just scaled versions of total seconds.

1df["minutes_int"] = (df["delta"].dt.total_seconds() / 60).round().astype("int64")
2df["hours_int"] = (df["delta"].dt.total_seconds() / 3600).round().astype("int64")
3
4print(df[["delta", "minutes_int", "hours_int"]])

For days, dividing by a timedelata is often the most readable:

df["days_int"] = (df["delta"] / pd.Timedelta(days=1)).astype("int64")

The point is not that one method is always best. The point is to make the target unit obvious from both the code and the column name.

Handle Missing Values Carefully

If the column contains NaT, a direct cast to plain int64 can fail. Use a nullable integer dtype when missing values must survive.

1df2 = pd.DataFrame({"delta": [pd.Timedelta(seconds=30), pd.NaT]})
2df2["seconds"] = df2["delta"].dt.total_seconds()
3df2["seconds_nullable"] = df2["seconds"].round().astype("Int64")
4
5print(df2)

This preserves missing values instead of forcing you to fill them with a possibly misleading number.

Avoid Row-Wise apply

Timedelta conversion should almost always be vectorized. Using apply row by row is slower and less idiomatic.

Prefer this:

df["seconds"] = df["delta"].dt.total_seconds()

Not this:

# slower and usually unnecessary
# df["seconds"] = df["delta"].apply(lambda x: x.total_seconds())

Pandas already exposes the efficient vectorized path.

Negative Durations and Business Rules

Durations can be negative. That may be valid, for example when measuring drift, clock skew, or schedule variance. In other domains, negative durations indicate bad data and should be rejected or clamped.

The conversion step itself will happily preserve negative values:

df3 = pd.DataFrame({"delta": [pd.Timedelta(seconds=-45)]})
df3["seconds"] = df3["delta"].dt.total_seconds().astype("int64")
print(df3)

So the real question is not "can pandas convert this" but "what do negative durations mean in my data model."

Name the Output Column by Unit

This sounds minor, but ambiguous column names cause real downstream mistakes. duration_int is worse than duration_seconds. Once the data leaves the notebook or ETL job, explicit unit naming is often the only thing preventing misinterpretation.

That is also why it is better to store one canonical unit and derive display-friendly units later than to scatter mixed-unit columns throughout a pipeline.

Common Pitfalls

The most common mistake is converting timedeltas to integers without defining the target unit. An integer with no unit is almost useless.

Another issue is losing missing values by forcing a non-nullable integer dtype. Use pandas nullable integer types if NaT needs to survive.

Developers also often mix rounding and truncation inconsistently across pipelines. That creates silent disagreements between reports.

Finally, avoid row-wise conversion when vectorized .dt accessors already solve the problem faster and more clearly.

Summary

• Convert pandas timedeltas to integers by first choosing an explicit unit.
• '.dt.total_seconds() is the standard starting point for seconds-based conversion.'
• Scale from seconds or divide by pd.Timedelta(...) for other units.
• Use nullable integer dtypes when missing durations must be preserved.
• Name output columns by unit so downstream code cannot misread them.