Master calculating minutes with clear steps, formulas, examples, and tools. Learn conversions, elapsed time, rounding, and automation in Excel, Google Sheets, Python, JavaScript, and SQL.
Category: Utils • Last Verified: September 2026
Quick Answer: To calculate minutes, multiply hours by 60 and add leftover minutes. For elapsed time, convert both times to minutes since midnight, subtract start from end, and add 1,440 if the interval crosses midnight. Example: 2:45 → 2×60 + 45 = 165 minutes. From 09:20 to 14:05 → 285 minutes. Decimal hours convert with hours × 60.
Calculating minutes is the process of converting time values into total minutes or finding the minute difference between two timestamps. It includes converting hours to minutes, minutes back to hours and minutes, handling elapsed time (including across midnight), and applying rounding policies for payroll, billing, and reporting.
We wrote this guide to be copy-pastable, legally cautious where it matters, and fast for everyday work. When we test methods, we check edge cases like midnight crossings, daylight saving time, and negative durations to prevent silent errors.
By the end, you’ll:
Accurate minute math prevents billing disputes, payroll errors, and SLA breaches. It keeps timesheets consistent, supports fair pay, and produces numbers that auditors, clients, and teammates can verify quickly. Once standardized, your workflows scale from a handful of entries to millions of rows.
Use the base formula:
Examples:
Tip: Split hours and minutes first. Don’t multiply the entire H:MM string.
Multiply by 60:
Examples:
Important: 1.5 hours equals 1 hour 30 minutes, not 1 hour 50 minutes. Decimal hours are base-10 fractions, not base-60.
Use division and remainder:
Examples:
Follow these steps:
Examples:
Use 24-hour time to avoid AM/PM ambiguity.
Rounding must be written, transparent, and consistent. Common policies:
Examples (nearest 15):
Compliance: In the U.S., 29 CFR 785.48(b) permits rounding if it does not, over time, result in underpayment. Requirements vary by country/state. Get legal review before rollout.
Times are stored as fractions of a day. 1 day = 24 hours = 1,440 minutes.
Core conversions:
Crossing midnight:
Rounding policies:
Formatting tips:
Quality checks we use:
We recommend using modern, timezone-aware libraries and storing UTC where possible. Avoid manual string subtraction for anything beyond same-day local intervals.
from datetime import datetime, timedelta
from zoneinfo import ZoneInfo # Python 3.9+
def minutes_between_local(start_str, end_str, tz="America/New_York", fmt="%Y-%m-%d %H:%M"):
tzinfo = ZoneInfo(tz)
start = datetime.strptime(start_str, fmt).replace(tzinfo=tzinfo)
end = datetime.strptime(end_str, fmt).replace(tzinfo=tzinfo)
# Handle end before start by adding a day
if end < start:
end += timedelta(days=1)
return int((end - start).total_seconds() // 60)
print(minutes_between_local("2026-05-06 09:20", "2026-05-06 14:05")) # 285
print(minutes_between_local("2026-05-06 22:30", "2026-05-07 01:15")) # 165
# Hours/minutes ↔ minutes
hours, minutes = 2, 45
total = hours * 60 + minutes # 165
h = total // 60; m = total % 60 # 2, 45
# Decimal hours
decimal_hours = 2.75
print(int(decimal_hours * 60)) # 165
// Requires Temporal (TC39 Stage-4; available in modern runtimes in 2026)
function minutesBetweenZoned(startISO, endISO, timeZone) {
const start = Temporal.ZonedDateTime.from({
...Temporal.PlainDateTime.from(startISO).getISOFields(),
timeZone
});
const endBase = Temporal.ZonedDateTime.from({
...Temporal.PlainDateTime.from(endISO).getISOFields(),
timeZone
});
const end = endBase < start ? endBase.add({ days: 1 }) : endBase;
return Math.floor(end.since(start).total('minutes'));
}
console.log(minutesBetweenZoned('2026-05-06T09:20', '2026-05-06T14:05', 'America/New_York')); // 285
// Fallback for simple same-day local times (no DST/timezone safety):
function minutesBetweenSimple(startHHMM, endHHMM) {
const [sh, sm] = startHHMM.split(":").map(Number);
const [eh, em] = endHHMM.split(":").map(Number);
let s = sh * 60 + sm;
let e = eh * 60 + em;
if (e < s) e += 24 * 60; // cross midnight
return e - s;
}
PostgreSQL:
-- Elapsed minutes between two timestamptz columns (timezone-aware)
SELECT EXTRACT(EPOCH FROM (end_ts - start_ts)) / 60 AS minutes
FROM sessions;
-- Time-of-day columns across midnight
SELECT (EXTRACT(HOUR FROM end_t) * 60 + EXTRACT(MINUTE FROM end_t))
- (EXTRACT(HOUR FROM start_t) * 60 + EXTRACT(MINUTE FROM start_t))
+ CASE WHEN end_t < start_t THEN 1440 ELSE 0 END AS minutes
FROM shifts;
MySQL 8+:
-- Timestamps (assumes DATETIME or TIMESTAMP)
SELECT TIMESTAMPDIFF(MINUTE, start_ts, end_ts) AS minutes
FROM sessions;
Caution: Cross-timezone math is simplest in UTC. Store times in UTC or store local time with its IANA zone and compute with timezone-aware functions.
| Method | Best for | Accuracy | DST/Time zones | Speed | Setup effort |
|---|---|---|---|---|---|
| Manual math | One-off checks | High if careful | Poor | Slow | None |
| Spreadsheet (Excel/Sheets) | Teams, audits, light automation | High | Medium (with dates) | Fast | Low |
| Code (Python/JS/SQL) | Apps, APIs, big data | Very high | High (with tz libs) | Very fast | Medium |
| Purpose-built tool | Non-technical users, policy enforcement | Very high | High | Fastest | None |
How do I calculate minutes quickly without a calculator? Convert hours to minutes (hours × 60), then add leftover minutes. For elapsed time, convert both to minutes since midnight and subtract; if end < start, add 1,440 to the end before subtracting. With practice, you’ll memorize anchors like 2 hours = 120 minutes and 15 minutes = a quarter-hour.
What’s the difference between decimal hours and minutes? Decimal hours are base-10 (2.5 = 2 hours 30 minutes). Minutes are base-60 segments of an hour. Confusion happens when people read 1.5 hours as 1:50 instead of 1:30. Pick a standard for input, then convert at import so everyone reads time the same way.
How do I calculate minutes between two times that cross midnight? Convert both times to minutes since midnight. If the end minutes are less than the start, add 1,440 to the end and then subtract. Example: 22:30 (1,350) to 01:15 (75) → (75 + 1,440) − 1,350 = 165 minutes. In spreadsheets, use MOD((end - start), 1) * 1,440.
How should I round minutes for payroll legally? Choose a single rounding policy (nearest 6 or 15, for example) and apply it uniformly. In the U.S., 29 CFR 785.48(b) allows rounding if it does not, over time, withhold pay. Document the rule in your handbook, include examples, and keep both raw and rounded minutes for audits.
How do I convert minutes to hours and minutes in Excel? Assume minutes in C2. Hours are =INT(C2/60) and leftover minutes are =MOD(C2,60). To display as H:MM in one cell: =INT(C2/60) & ":" & TEXT(MOD(C2,60),"00"). If you start with a true time value, multiply by 1,440 to get minutes, then format as Number.
Why does Excel or Google Sheets show a time instead of a number of minutes? Both store times as fractions of a day, so 1 hour is 1/24. If you display a time value with a Time format, it shows H:MM instead of a count. Convert to minutes with =A2*1440 (or =(B2-A2)*1440 for a duration), and format the result as Number, not Time.
How do I handle daylight saving time when calculating minutes? Include the date and compute in a timezone-aware context. In code, use libraries that know IANA zones (Python zoneinfo, JS Temporal.ZonedDateTime). In spreadsheets, convert timestamps to UTC before subtraction. Avoid naïve same-day assumptions on DST transition days; they add or remove 60 minutes.
Calculating minutes is straightforward once you standardize inputs, compute with a single reliable formula, and document rounding. Whether you’re working by hand, in a spreadsheet, or in code, the patterns here eliminate ambiguity and scale to real-world complexity like midnight crossings and DST.
Want this done for you? Try the ZenixTools Time Difference Calculator to standardize inputs, calculate raw and rounded minutes, and export clean reports for payroll and billing.
A complete, expert guide to creating secure Wi‑Fi QR codes that just work on iPhone and Android, with best practices and a step‑by‑step workflow.
Learn how to convert 1 meter to feet with precise formulas, quick methods, and real-world examples. Includes best practices, common mistakes, comparison tables, FAQs, and expert tips for accurate length conversions.
What’s the safest way to calculate minutes in JavaScript? Use the Temporal API with ZonedDateTime for any date- or zone-aware math. Convert inputs to RFC 3339 strings, construct ZonedDateTime, adjust for midnight by adding a day if needed, and subtract with since('minutes'). Only use legacy Date or "HH:MM" parsing for same-day, zone-agnostic, non-DST intervals.
How do I calculate minutes between timestamps in SQL? Use built-in functions. In PostgreSQL: EXTRACT(EPOCH FROM (end_ts - start_ts))/60 for timestamptz columns. In MySQL: TIMESTAMPDIFF(MINUTE, start_ts, end_ts). Include dates for DST correctness. For time-of-day columns that may cross midnight, add 1,440 if end < start to get a positive duration.
How do I convert 2.75 hours to minutes and back? Multiply by 60: 2.75 × 60 = 165 minutes. To convert back, divide and separate remainder: 165 ÷ 60 = 2 hours with 45 minutes leftover. In Excel or Sheets, minutes in C2: hours = INT(C2/60), minutes = MOD(C2,60), formatted together as =INT(C2/60) & ":" & TEXT(MOD(C2,60),"00").
What are common mistakes when calculating minutes? The biggest are mixing decimal hours with H:MM, forgetting midnight rollover, and double rounding (per line and total). Others include AM/PM errors, DST surprises, and spreadsheet formatting that hides negative durations. Standardize inputs, store raw minutes as numbers, and test known edge cases.
How can I reduce disputes about billed minutes? Publish your rounding rule with examples, and keep raw minutes alongside rounded minutes. Use consistent timestamps (RFC 3339) and store evidence (ticket logs, call records). Share an audit view that shows start, end, breaks, raw minutes, and rounded minutes so clients can verify totals quickly.
What format should I use to store times? For systems and APIs, use RFC 3339 (ISO 8601 profile) in UTC, like 2026-09-01T08:00:00Z. For human data entry, use 24-hour local time with an accompanying date. Internally, store raw durations as integer minutes for easy sums, reporting, and rounding without floating-point issues.
How do I calculate minutes across time zones? Convert both timestamps to a common zone—preferably UTC—before subtraction. In code, parse with timezone-aware libraries and call the difference in minutes. In SQL, use timestamptz and functions that account for time zones. Never subtract raw strings from different zones directly.
When should I not use rounding at all? Skip rounding when contracts bill by the minute, SLAs trigger at exact thresholds, or legal requirements demand precise pay. Also avoid rounding when you aggregate many short intervals; the error can compound. If you must round for readability, store exact raw minutes and round only on the display layer.