Does the calculator understand ISO 8601 durations?

Yes. Strings like PT1H30M, P1DT12H, or PT0.5S are parsed directly, and any computed result can be exported back to ISO 8601 form.

How are months and years handled in duration math?

Months and years are calendar-dependent, so the calculator only uses fixed-length units (weeks down to milliseconds) for arithmetic. For month or year offsets, use the Date Add / Subtract tool.

What about leap seconds?

Leap seconds are ignored, matching the POSIX time model used by JavaScript and most programming languages. A minute is always treated as 60 seconds.

Is anything uploaded?

No. All duration parsing and math run locally in your browser.

diff · breakdown · units · live

Calculate the duration between two moments

Pick a start and end and see the diff broken down to days/hours/minutes/seconds plus every common unit conversion.

Duration Calculator

Status

fill

two dates

Days

—

whole

Hours

—

total

Minutes

—

total

input · range

Start

—

End

—

output · breakdown

Pick start and end to compute the duration.

Quick Start

How duration math works

Both dates are parsed as JavaScript Date objects. The absolute difference is broken down into days / hours / minutes / seconds plus rolled-up unit conversions.

01
Choose two moments
Local datetime-local inputs accept date and time of day.
Parsing accepts ISO 8601, RFC 3339, RFC 2822, and Unix epoch seconds/milliseconds. The Date constructor handles the rest with browser-engine consistency.
inputISO 8601RFC 3339epochlive
in · timestampdatetime · ISO
```
start, end
```
loaded · ISO 8601zone · ready
02
Absolute diff
Order doesn't matter — the result is always positive.
All math runs in UTC internally to avoid DST landmines; presentation converts back to the user’s zone via Intl.DateTimeFormat.
absUTC mathIntlDST-safelive
|b-a| · optionsms · live
```
|b - a|
```
options applied · UTCDST-safe
03
Breakdown
Days, hours, minutes, seconds — humans-first.
Output respects the chosen timezone offset (Z vs +05:30) and pads digits per ISO conventions so sorts stay chronological.
breakdownoffsetzone-awaresortablepadded
out · computedDd Hh · ready
```
3d 4h 12m 5s
```
computed · instantsortable
04
Unit grid
Every common rollup unit is listed so you can copy whatever your code expects.
Copy writes via the Async Clipboard API; nothing pings a time server — the browser’s clock is the only oracle.
unitsclipboardno oracledeterministicclient-side
✓ · copiedready · done
```
✓ Copied
```
shipped · ready to shipsuccess

Pro tips

Time math without DST landmines

Always store UTC

Convert to local for display only. UTC storage avoids DST jumps and timezone drift in databases.

Watch leap seconds

POSIX time doesn’t count leap seconds; some systems do. Don’t use timestamps for sub-second precision across boundaries.

Prefer Temporal eventually

The Date API has many quirks. Temporal is shipping in modern engines and handles zones correctly.

Cron is timezone-tricky

Cron expressions run in the daemon’s local zone unless told otherwise. Pin a TZ explicitly for predictable runs.

ISO 8601 sorts naturally

YYYY-MM-DDTHH:mm:ss sorts correctly as a string. Don’t use US-style MM/DD/YYYY for anything machine-readable.

Beware Y2K38

Signed 32-bit Unix timestamps overflow in 2038. Use 64-bit storage end-to-end for long-lived systems.

Use Cases

When to compute durations

Logs, SLAs, billing.

SLA reporting

How long was the outage? Paste two timestamps from your monitor. Math runs in UTC under the hood to dodge DST jumps — local time is only for display. That means scheduling logic and date diffs survive March / November fall-back without the classic off-by-one-hour bug.

DST-safe

Billing periods

Compute exact hours between start and end of a contract. Browser clock is the only source — no external time server, no privacy leak, no rate limit. Pair with NTP-synced server time for high-accuracy use cases, but for human-scale work the browser clock is plenty.

UTC-correct

Project timelines

Total weeks between kickoff and launch. ISO 8601 output sorts naturally as strings, perfect for filenames (report-2026-01-15.pdf) and log lines that need chronological ordering without parsing. Drop into S3 keys for free time-bucketing.

ISO-sortable

Test fixtures

Pre-compute ms deltas for snapshot assertions. Pairs cleanly with cron, scheduled tasks, and timestamped log analysis. The tool's output drops directly into APScheduler, Linux cron, or GitHub Actions schedule expressions without re-formatting.

spec-grade

Performance

Sanity-check elapsed time across two log lines. Output respects the chosen timezone offset (Z vs +05:30) so REST APIs and database TIMESTAMP WITH TIME ZONE columns round-trip cleanly. No ambiguity between "noon UTC" and "noon local".

zone-aware

Travel

How many days between two trip endpoints? Confirms the difference between epoch seconds (10 digits) and milliseconds (13 digits) before you commit code that mis-multiplies by 1000 — a classic bug in cross-language time handling.

epoch-accurate

FAQ

Frequently asked questions

Does it account for DST?

Inputs are interpreted in your browser's timezone. DST gaps are reflected in the absolute millisecond diff.

Why is the year value approximate?

Years vary in length — we divide by 365.25 days, the average tropical year.

Can I paste an ISO string?

Yes, but the datetime-local input expects YYYY-MM-DDTHH:mm — paste that form.

What about timezones?

Use ISO 8601 Converter or Timezone Converter to normalize first, then come back.

Is anything sent to a server?

No. The diff is computed locally.

Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

47 in queue·8 shipped this month

Request queued. Thanks!