Whether you're tracking a project deadline, calculating the duration of a contract, or simply counting down to a vacation, date calculations are something nearly everyone encounters. Despite seeming straightforward, computing the exact number of days between two dates—or adding days while accounting for weekends, holidays, and leap years—can get surprisingly tricky.

This guide walks through everything you need to know about date math: from simple day-counting formulas to working-day calculations, complete with copy-paste code examples in JavaScript, Python, and Excel.

Table of Contents

TL;DR

  • Days between two dates: Subtract the two dates and convert the result to days. In JavaScript, divide the millisecond difference by 86400000. In Python, subtract two date objects to get a timedelta. In Excel, subtract one cell from another.
  • Add/subtract days: Use setDate() in JavaScript, timedelta in Python, or simple addition in Excel.
  • Working days: Exclude weekends (and optionally holidays) from the total. Use Excel's NETWORKDAYS function or iterate through dates in code.
  • Time zones: Always normalize to UTC before performing date arithmetic to avoid off-by-one errors caused by Daylight Saving Time transitions.
  • Skip the manual math: Use the Date Calculator for instant, accurate results.

Introduction

Date calculations appear everywhere in software development and daily life. A project manager needs to know how many working days remain before a release. A lawyer must determine whether a statute of limitations has expired. A finance team calculates accrued interest based on exact day counts. Even planning a birthday party requires counting the days until the big event.

While the concept is simple—how many days from A to B—the implementation details matter. Months have varying lengths (28, 29, 30, or 31 days). Leap years add an extra day to February. Time zones can shift a date forward or backward. Business-day calculations need to exclude weekends and holidays that vary by country.

This guide covers the core techniques for performing date calculations accurately, with practical code examples you can use immediately. If you need a quick answer without writing code, the Date Calculator handles all of this in your browser.

How to Calculate Days Between Two Dates

The Basic Formula

The fundamental approach to finding the number of days between two dates is:

code 
Days = End Date − Start Date

In most programming environments, dates are represented internally as numbers (milliseconds since the Unix epoch in JavaScript, ordinal days in Python, serial numbers in Excel). Subtracting two date values gives you the raw difference, which you then convert to days.

Key considerations:

  1. Inclusive vs. exclusive counting — Does "from January 1 to January 3" equal 2 days or 3 days? It depends on whether you count both endpoints. Most date libraries return the exclusive difference (2 days in this case).
  2. Time component — If your dates include a time portion, the difference might not be an exact whole number. Truncate or round as needed.
  3. Leap years — February has 29 days in leap years. Standard libraries handle this automatically, but manual calculations must account for it.

JavaScript Implementation

JavaScript's Date object stores dates as milliseconds since January 1, 1970 UTC. To find the difference in days:

javascript 
function daysBetween(startDate, endDate) {
  const MS_PER_DAY = 1000 * 60 * 60 * 24;
  const start = new Date(startDate);
  const end = new Date(endDate);

  const utcStart = Date.UTC(start.getFullYear(), start.getMonth(), start.getDate());
  const utcEnd = Date.UTC(end.getFullYear(), end.getMonth(), end.getDate());

  return Math.floor((utcEnd - utcStart) / MS_PER_DAY);
}

daysBetween('2026-01-01', '2026-12-31');
// 364

daysBetween('2026-03-01', '2026-04-01');
// 31

Using Date.UTC() strips out time zone offsets, ensuring the calculation is based purely on calendar dates. Without it, Daylight Saving Time transitions could produce off-by-one errors.

For a more robust solution with the popular date-fns library:

javascript 
import { differenceInDays, differenceInCalendarDays } from 'date-fns';

differenceInCalendarDays(new Date('2026-12-31'), new Date('2026-01-01'));
// 364

differenceInDays(new Date('2026-12-31T23:00:00'), new Date('2026-01-01T01:00:00'));
// 364

Python Implementation

Python's datetime module makes date subtraction straightforward:

python 
from datetime import date

start = date(2026, 1, 1)
end = date(2026, 12, 31)

delta = end - start
print(delta.days)
# 364

The subtraction returns a timedelta object whose .days attribute gives the whole-number difference. This handles leap years and varying month lengths automatically.

For parsing date strings:

python 
from datetime import datetime

start = datetime.strptime("2026-03-15", "%Y-%m-%d").date()
end = datetime.strptime("2026-07-20", "%Y-%m-%d").date()

print((end - start).days)
# 127

With dateutil for more flexible parsing:

python 
from dateutil.parser import parse

start = parse("March 15, 2026").date()
end = parse("July 20, 2026").date()

print((end - start).days)
# 127

Excel Formulas

Excel stores dates as serial numbers (the number of days since January 1, 1900), making date arithmetic as simple as subtraction.

Simple subtraction:

code 
=B2-A2

If A2 contains 2026-01-01 and B2 contains 2026-12-31, the result is 364. Format the result cell as a Number (not Date) to see the day count.

DATEDIF function:

code 
=DATEDIF(A2, B2, "D")

The third argument specifies the unit: "D" for days, "M" for complete months, "Y" for complete years.

code 
=DATEDIF("2026-01-01", "2026-04-01", "D")   → 90
=DATEDIF("2026-01-01", "2026-04-01", "M")   → 3
=DATEDIF("2020-06-15", "2026-06-15", "Y")   → 6

DAYS function (Excel 2013+):

code 
=DAYS(B2, A2)

This is equivalent to simple subtraction but more readable and handles text-formatted dates.

How to Add or Subtract Days from a Date

Adding Days

Adding a specific number of days to a date is essential for calculating deadlines, expiration dates, and delivery estimates.

JavaScript:

javascript 
function addDays(dateStr, days) {
  const date = new Date(dateStr);
  date.setDate(date.getDate() + days);
  return date.toISOString().split('T')[0];
}

addDays('2026-01-15', 30);
// "2026-02-14"

addDays('2026-01-31', 30);
// "2026-03-02"

addDays('2026-02-28', 1);
// "2026-03-01" (2026 is not a leap year)

addDays('2024-02-28', 1);
// "2024-02-29" (2024 is a leap year)

JavaScript's setDate() automatically handles month and year rollovers. Setting the date to 32 on a 31-day month rolls over to the 1st of the next month.

Python:

python 
from datetime import date, timedelta

start = date(2026, 1, 15)
result = start + timedelta(days=30)
print(result)
# 2026-02-14

result = date(2026, 3, 1) + timedelta(days=90)
print(result)
# 2026-05-30

Excel:

code 
=A2+30

Simply add the number of days to a date cell. Excel's serial number system makes this trivial.

Subtracting Days

Subtracting days works identically—just use a negative number.

JavaScript:

javascript 
function subtractDays(dateStr, days) {
  const date = new Date(dateStr);
  date.setDate(date.getDate() - days);
  return date.toISOString().split('T')[0];
}

subtractDays('2026-03-01', 1);
// "2026-02-28"

subtractDays('2026-01-01', 1);
// "2025-12-31"

Python:

python 
from datetime import date, timedelta

result = date(2026, 3, 1) - timedelta(days=1)
print(result)
# 2026-02-28

result = date(2026, 1, 1) - timedelta(days=365)
print(result)
# 2025-01-01

Excel:

code 
=A2-30

Common Use Cases

Scenario Calculation Example
Payment due date Invoice date + net days Mar 1 + 30 = Mar 31
Subscription renewal Start date + subscription period Jan 15 + 365 = Jan 15 next year
Contract expiration Signing date + contract term Jun 1, 2026 + 730 days = Jun 1, 2028
Delivery estimate Ship date + transit days Apr 5 + 7 = Apr 12
Warranty end date Purchase date + warranty period Dec 25, 2025 + 365 = Dec 25, 2026
Passport renewal Expiry date − 180 days Jan 1, 2028 − 180 = Jul 5, 2027

For quick calculations without opening a code editor, the Date Calculator lets you add or subtract any number of days, weeks, months, or years from a given date.

Working Days Calculator: Excluding Weekends and Holidays

What Are Working Days

Working days (also called business days) are weekdays from Monday through Friday, excluding public holidays. This distinction matters in many real-world scenarios:

  • Legal deadlines: Courts and regulators often specify deadlines in business days.
  • Shipping estimates: Carriers typically only operate on business days.
  • Financial settlements: Stock trades settle in T+2 business days.
  • Project timelines: Sprint planning uses working days to estimate effort.

The relationship between calendar days and business days varies, but a common approximation is:

Calendar Days Approximate Business Days
7 5
14 10
30 22
60 44
90 66
365 261

JavaScript Implementation

Here's a function to count working days between two dates:

javascript 
function getWorkingDays(startDate, endDate) {
  const start = new Date(startDate);
  const end = new Date(endDate);
  let count = 0;
  const current = new Date(start);

  while (current <= end) {
    const dayOfWeek = current.getDay();
    if (dayOfWeek !== 0 && dayOfWeek !== 6) {
      count++;
    }
    current.setDate(current.getDate() + 1);
  }

  return count;
}

getWorkingDays('2026-04-01', '2026-04-30');
// 22

getWorkingDays('2026-01-01', '2026-12-31');
// 261

For better performance with large date ranges, avoid iterating day by day. Instead, calculate using complete weeks:

javascript 
function getWorkingDaysFast(startDate, endDate) {
  const start = new Date(startDate);
  const end = new Date(endDate);
  const MS_PER_DAY = 86400000;

  let totalDays = Math.floor((end - start) / MS_PER_DAY) + 1;
  let fullWeeks = Math.floor(totalDays / 7);
  let remainingDays = totalDays % 7;

  let workingDays = fullWeeks * 5;

  let startDay = start.getDay();
  for (let i = 0; i < remainingDays; i++) {
    let day = (startDay + i) % 7;
    if (day !== 0 && day !== 6) {
      workingDays++;
    }
  }

  return workingDays;
}

getWorkingDaysFast('2026-01-01', '2026-12-31');
// 261

Python:

python 
from datetime import date, timedelta

def working_days_between(start, end):
    count = 0
    current = start
    while current <= end:
        if current.weekday() < 5:
            count += 1
        current += timedelta(days=1)
    return count

print(working_days_between(date(2026, 4, 1), date(2026, 4, 30)))
# 22

Python also has the numpy approach for large-scale calculations:

python 
import numpy as np

start = np.datetime64('2026-04-01')
end = np.datetime64('2026-04-30')

print(np.busday_count(start, end))
# 21 (exclusive of end date)

Excel NETWORKDAYS Function

Excel provides a built-in function specifically for working day calculations:

code 
=NETWORKDAYS(start_date, end_date, [holidays])

Examples:

code 
=NETWORKDAYS("2026-04-01", "2026-04-30")
→ 22

=NETWORKDAYS("2026-01-01", "2026-12-31")
→ 261

To exclude holidays, pass a range of holiday dates as the third argument:

code 
=NETWORKDAYS("2026-01-01", "2026-12-31", D2:D12)

Where D2:D12 contains your list of public holiday dates.

NETWORKDAYS.INTL lets you define custom weekends (e.g., Friday-Saturday in some countries):

code 
=NETWORKDAYS.INTL("2026-04-01", "2026-04-30", "0000011")

The weekend string "0000011" marks Saturday and Sunday as non-working days (1 = non-working). For a Friday-Saturday weekend, use "0000110".

Handling Public Holidays

Public holidays vary by country, region, and even industry. A robust working-day calculator must account for these. Here's a JavaScript implementation that accepts a list of holidays:

javascript 
function getWorkingDaysExcludingHolidays(startDate, endDate, holidays = []) {
  const start = new Date(startDate);
  const end = new Date(endDate);
  const holidaySet = new Set(holidays.map(h => new Date(h).toISOString().split('T')[0]));

  let count = 0;
  const current = new Date(start);

  while (current <= end) {
    const dayOfWeek = current.getDay();
    const dateStr = current.toISOString().split('T')[0];

    if (dayOfWeek !== 0 && dayOfWeek !== 6 && !holidaySet.has(dateStr)) {
      count++;
    }
    current.setDate(current.getDate() + 1);
  }

  return count;
}

const usHolidays2026 = [
  '2026-01-01', // New Year's Day
  '2026-01-19', // MLK Day
  '2026-02-16', // Presidents' Day
  '2026-05-25', // Memorial Day
  '2026-07-03', // Independence Day (observed)
  '2026-09-07', // Labor Day
  '2026-11-26', // Thanksgiving
  '2026-12-25', // Christmas
];

getWorkingDaysExcludingHolidays('2026-01-01', '2026-12-31', usHolidays2026);
// 253

Python with holidays library:

python 
import holidays
from datetime import date, timedelta

us_holidays = holidays.US(years=2026)

def working_days_excluding_holidays(start, end, holiday_dict):
    count = 0
    current = start
    while current <= end:
        if current.weekday() < 5 and current not in holiday_dict:
            count += 1
        current += timedelta(days=1)
    return count

print(working_days_excluding_holidays(date(2026, 1, 1), date(2026, 12, 31), us_holidays))

Date Math Across Time Zones

UTC vs Local Time

When performing date calculations, time zones can introduce subtle bugs. Consider a server in New York (UTC-5) processing a request from a user in Tokyo (UTC+9). The "current date" differs by up to 14 hours between them.

The golden rule: always perform date arithmetic in UTC, then convert to local time for display.

JavaScript:

javascript 
const nowUTC = new Date();
console.log(nowUTC.toISOString());
// "2026-04-01T12:00:00.000Z"

console.log(nowUTC.toLocaleDateString('en-US', { timeZone: 'America/New_York' }));
// "4/1/2026"

console.log(nowUTC.toLocaleDateString('en-US', { timeZone: 'Asia/Tokyo' }));
// "4/1/2026" (or "4/2/2026" depending on the time)

Python:

python 
from datetime import datetime, timezone
import zoneinfo

now_utc = datetime.now(timezone.utc)

eastern = now_utc.astimezone(zoneinfo.ZoneInfo("America/New_York"))
tokyo = now_utc.astimezone(zoneinfo.ZoneInfo("Asia/Tokyo"))

print(eastern.date())
print(tokyo.date())

For deeper exploration of time zone handling and epoch time conversion, see our Timestamp Converter.

Common Pitfalls

1. Daylight Saving Time (DST) Transitions

When clocks spring forward, a day might only have 23 hours. When they fall back, a day might have 25 hours. If you calculate date differences using raw milliseconds without normalizing to UTC dates first, you can get incorrect results.

javascript 
const march13 = new Date('2026-03-07T00:00:00-05:00');
const march15 = new Date('2026-03-09T00:00:00-04:00');

const diffMs = march15 - march13;
const diffDays = diffMs / (1000 * 60 * 60 * 24);
console.log(diffDays);
// 1.9583... (not exactly 2, because of DST)

The fix is to use Date.UTC() or Math.round() when converting milliseconds to days.

2. Date-only vs. DateTime Comparisons

Comparing a date string "2026-04-01" with a DateTime like new Date() can produce unexpected results because the date string is interpreted as midnight UTC while new Date() uses local time.

javascript 
const dateOnly = new Date('2026-04-01');
console.log(dateOnly.toISOString());
// "2026-04-01T00:00:00.000Z" (UTC midnight)

const localNow = new Date('2026-04-01T10:30:00');
console.log(localNow.toISOString());
// depends on local timezone

3. Off-by-one Errors

"From April 1 to April 3" — is that 2 days or 3 days? It depends on your counting method:

  • Exclusive (most common in programming): April 3 − April 1 = 2 days
  • Inclusive (common in legal/business contexts): April 1, April 2, April 3 = 3 days

Always clarify which convention applies to your use case.

Date Calculation in Different Scenarios

Project Management

Date calculations are central to planning sprints, releases, and milestones.

Sprint planning:

A typical Scrum sprint is 2 weeks (10 working days). Knowing your sprint start date, you can calculate:

javascript 
function sprintEndDate(startDate, sprintDays = 10) {
  const start = new Date(startDate);
  let workingDaysAdded = 0;

  while (workingDaysAdded < sprintDays) {
    start.setDate(start.getDate() + 1);
    const day = start.getDay();
    if (day !== 0 && day !== 6) {
      workingDaysAdded++;
    }
  }

  return start.toISOString().split('T')[0];
}

sprintEndDate('2026-04-01');
// "2026-04-15"

Milestone tracking:

Calculate the percentage of time elapsed in a project:

python 
from datetime import date

project_start = date(2026, 1, 15)
project_end = date(2026, 6, 30)
today = date(2026, 4, 1)

total_days = (project_end - project_start).days
elapsed_days = (today - project_start).days
progress = (elapsed_days / total_days) * 100

print(f"Project progress: {progress:.1f}%")
# Project progress: 45.6%

Legal contexts often require precise date calculations with specific rules.

Statute of limitations:

python 
from datetime import date, timedelta

incident_date = date(2024, 6, 15)
limitation_period_years = 2
limitation_period_days = limitation_period_years * 365

expiry_date = incident_date + timedelta(days=limitation_period_days)
today = date(2026, 4, 1)

if today <= expiry_date:
    remaining = (expiry_date - today).days
    print(f"Statute expires in {remaining} days on {expiry_date}")
else:
    print("Statute of limitations has expired")

# Statute expires in 75 days on 2026-06-15

Contract period calculation:

Many contracts specify durations in months rather than days. Be aware that "3 months from January 31" is ambiguous—does it end on April 30 or May 1? Python's dateutil.relativedelta handles this:

python 
from dateutil.relativedelta import relativedelta
from datetime import date

contract_start = date(2026, 1, 31)
contract_end = contract_start + relativedelta(months=3)
print(contract_end)
# 2026-04-30

Personal

Age calculation:

javascript 
function calculateAge(birthDateStr) {
  const birth = new Date(birthDateStr);
  const today = new Date();

  let age = today.getFullYear() - birth.getFullYear();
  const monthDiff = today.getMonth() - birth.getMonth();

  if (monthDiff < 0 || (monthDiff === 0 && today.getDate() < birth.getDate())) {
    age--;
  }

  return age;
}

calculateAge('1990-08-25');
// 35 (as of April 2026)

Countdown to an event:

python 
from datetime import date

event_date = date(2026, 12, 25)
today = date(2026, 4, 1)
remaining = (event_date - today).days

print(f"{remaining} days until Christmas!")
# 268 days until Christmas!

Days alive:

javascript 
function daysAlive(birthDateStr) {
  const birth = new Date(birthDateStr);
  const today = new Date();
  const MS_PER_DAY = 86400000;

  return Math.floor((today - birth) / MS_PER_DAY);
}

daysAlive('1990-08-25');
// ~13,003 days (as of April 2026)

Financial

Simple interest calculation period:

python 
from datetime import date

deposit_date = date(2026, 1, 1)
maturity_date = date(2026, 7, 1)
principal = 10000
annual_rate = 0.05

days = (maturity_date - deposit_date).days
interest = principal * annual_rate * (days / 365)

print(f"Days: {days}")
print(f"Interest: ${interest:.2f}")
# Days: 181
# Interest: $247.95

Payment schedule generation:

javascript 
function generatePaymentSchedule(startDate, intervalDays, numberOfPayments) {
  const schedule = [];
  const current = new Date(startDate);

  for (let i = 0; i < numberOfPayments; i++) {
    schedule.push({
      payment: i + 1,
      date: current.toISOString().split('T')[0],
    });
    current.setDate(current.getDate() + intervalDays);
  }

  return schedule;
}

generatePaymentSchedule('2026-04-01', 30, 6);
// [
//   { payment: 1, date: "2026-04-01" },
//   { payment: 2, date: "2026-05-01" },
//   { payment: 3, date: "2026-05-31" },
//   { payment: 4, date: "2026-06-30" },
//   { payment: 5, date: "2026-07-30" },
//   { payment: 6, date: "2026-08-29" }
// ]

Day-count conventions in finance:

Financial instruments use specific conventions for counting days in interest periods:

Convention Description Used By
Actual/365 Actual days divided by 365 UK government bonds
Actual/360 Actual days divided by 360 US money markets
30/360 Assumes 30-day months and 360-day years US corporate bonds
Actual/Actual Actual days in period / actual days in year US Treasury bonds

Frequently Asked Questions

How do you calculate the number of days between two dates?

Subtract the earlier date from the later date. In JavaScript, convert both to timestamps and divide the difference by 86400000 (ms per day). In Excel, simply subtract one cell from another. Online tools like QubitTool's Date Calculator do this instantly.

How do you add days to a date?

Create a date object and add the desired number of days. In JavaScript, use setDate(getDate() + n). In Python, use timedelta(days=n). In Excel, simply add the number to a date cell. This is useful for calculating deadlines and due dates.

How do you calculate working days between two dates?

Count all days between two dates, then exclude weekends (Saturdays and Sundays) and optionally public holidays. In Excel, use the NETWORKDAYS function. In code, iterate through each day and check if it falls on a weekday.

What is the difference between calendar days and business days?

Calendar days include every day (weekdays, weekends, holidays), while business days only count Monday through Friday, excluding public holidays. A 30-calendar-day period typically contains about 22 business days.

How do you handle leap years in date calculations?

Leap years add one day (Feb 29) every 4 years, except for century years not divisible by 400. Most programming languages and date libraries handle leap years automatically. When calculating manually, check if the year is divisible by 4 (and by 400 for century years).

Here's a quick reference for leap year rules:

javascript 
function isLeapYear(year) {
  return (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
}

isLeapYear(2024); // true
isLeapYear(2025); // false
isLeapYear(2000); // true
isLeapYear(1900); // false
python 
import calendar

calendar.isleap(2024)  # True
calendar.isleap(2025)  # False
calendar.isleap(2000)  # True
calendar.isleap(1900)  # False

Conclusion

Date calculations are deceptively complex. Between varying month lengths, leap years, time zones, DST transitions, and the distinction between calendar days and business days, there are many places where subtle bugs can creep in. The key takeaways:

  1. Use established libraries — Don't reinvent date math. Use date-fns or dayjs in JavaScript, datetime and dateutil in Python, and built-in functions in Excel.
  2. Normalize to UTC — Always perform arithmetic in UTC to avoid time zone and DST issues.
  3. Clarify your counting method — Know whether your use case requires inclusive or exclusive counting, calendar days or business days.
  4. Account for holidays — Working-day calculations are only accurate if you include the relevant holiday calendar for your region.
  5. Test edge cases — Leap years, month boundaries, year boundaries, and DST transitions are where date bugs hide.

For everyday date calculations—days between dates, adding or subtracting days, or counting working days—skip the manual math and use the Date Calculator. It runs entirely in your browser, handles all edge cases, and gives you instant results. Pair it with the Timestamp Converter when you need to work with Unix timestamps alongside human-readable dates.