Download your result as a plain text file. Change any field above and press Calculate to refresh it.

An age calculator turns a date of birth into an exact age by counting whole years first, then whole months, then the leftover days.

Rule of thumb: never divide days by 365. That overstates age by about one day for every four years lived, because roughly one year in four has 366 days. Count real calendar days instead.

Every age calculator has to choose a method, and this one counts completed periods. Age also has one rule that surprises people: you are 0 years old on the day you are born and turn 1 on your first birthday. The years figure is unambiguous. The months and days are where calculators disagree, because some count whole months from your birth day of the month and others divide the leftover days by an average month of 30.44 days. This tool uses the first method, which is what official forms and spreadsheets use.

How do I calculate my age manually, without an age calculator?

Subtract the birth year from the current year, then take one off if your birthday has not arrived yet this year. For the months and days, count whole months from your birth day of the month, then the days left over. Born 15 June 1995, on 30 August 2026: 31 years, 2 months, 15 days.

How many days old am I?

Subtract your date of birth from today and count every real day, leap days included. A person born on 15 June 1995 has lived 11,399 days by 30 August 2026. Multiplying 31 years by 365 gives 11,315, which is 84 days short, because it ignores eight leap days and the extra months.

What is the Excel formula for age from date of birth?

Use =DATEDIF(A2,TODAY(),"Y") for whole years. Add "YM" for the leftover months and "MD" for the leftover days to build the full age. DATEDIF is undocumented in Excel's function list but present in every version, and it is the only built-in that gives a true calendar age.

At what age does a person turn one year old?

On their first birthday, one year after the date of birth. You are 0 years old for your entire first year of life. This is the international convention. East Asian age reckoning historically counted a newborn as one and added a year each new year, a system South Korea formally left in June 2023.

How do I find my age on a future date?

Change the age as of field from today to the date you care about. Someone born on 15 June 1995 will be 34 years, 6 months and 17 days old on 1 January 2030. This is how you check school entry cutoffs, pension eligibility and licence age thresholds before the date arrives.

Why do two age calculators give different answers?

The years almost always match. The months and days differ because of the borrow method: when the current day of the month is earlier than your birth day, a month has to be borrowed, and tools disagree about which month's length to borrow. That produces answers one or two days apart.

An age calculator takes two dates, a date of birth and a reference date, and reports how much time separates them in the units people actually use. Age is not a subtraction of years. It is a count of completed periods: completed years first, then completed months inside the leftover part of the year, then the days left over after that. You are 31 the whole way from your 31st birthday to the day before your 32nd, and the months and days tell you where in that stretch you are standing.

The reason this needs a calculator at all is that months have different lengths. Subtracting 15 June from 30 August is easy. Subtracting 31 January from 1 March is not, because the answer depends on whether February had 28 or 29 days that year. Dates are written in a standard form under ISO 8601, but the standard says nothing about how to count age, so every tool has to choose a method and state it.

A worked one-liner: born 15 June 1995, measured on 30 August 2026. The birthday has passed this year, so the years are 2026 minus 1995, which is 31. From 15 June to 15 August is 2 whole months. From 15 August to 30 August is 15 days. The answer is 31 years, 2 months and 15 days.

A note on the method this tool uses, and why. When the reference day of the month is earlier than the birth day of the month, a month has to be borrowed, and the size of that borrow decides the answer. This calculator borrows the length of the month before the reference month, which is what Excel's DATEDIF, Python's relativedelta and most official forms do. Some calculators borrow the month before the birth month instead, and some skip the borrow entirely by dividing leftover days by 30.44. Those choices are why two tools can hand you answers a day or two apart while both look right. The years figure is never affected, which is why every legal use of age relies on years alone.

Who needs an exact age and why. Paediatricians plot growth against age in months, not years, because a two month difference matters enormously at that stage. Schools apply an entry cutoff on a fixed date. Pension and benefit systems test age to the day. Sports leagues band players by age at a season cutoff. Insurers price on age next birthday. Clinical trials set inclusion criteria in years. In every one of those the person asking wants a whole number of years and the date it changes, not a decimal.

The three ways of measuring age, compared.

Conclusion: calendar age and total days are both exact and both useful. The decimal versions exist for convenience in models, and the divide-by-365 version exists only as a mistake.

4.1 What your years, months and days actually mean

An age calculator reports three numbers, and they answer different questions. The years figure is your age in the everyday sense, and it is the only part that appears on a form. It counts completed years, so it stays fixed for a full 365 or 366 days and then jumps by one overnight. The months and days tell you how deep into your current year of life you are. Two months and fifteen days means you passed your last birthday two and a half months ago and your next one is still most of a year away.

4.2 Why total days is often the more useful number

Total days is a straight subtraction with no borrowing, no month lengths and no convention to argue about, which makes it the number that never disagrees between tools. It is also the right unit for very young children, where a difference of weeks is clinically meaningful, and for anything being compared statistically, where a smooth continuous measure beats a step function that jumps once a year.

4.3 The leap days hidden inside your age

Roughly one year in four contains a 29 February. Over 31 years you cross about 8 of them, which is why 31 years is 11,399 days rather than the 11,315 that multiplying by 365 suggests. The gap grows with age: by 80 the divide-by-365 shortcut is about 20 days out. This is not a rounding quibble. In any context that counts days rather than years, it is a real error with a predictable direction.

4.4 What your birth weekday tells you

Your birthday does not simply move forward one weekday each year. A common year is 365 days, which is 52 weeks plus 1 day, so the weekday advances by one. A leap year adds a second day. The result is that your birthday returns to the same weekday after 5, 6 or 11 years, in a pattern that depends on where your birthday sits relative to 29 February. That is why some people go a decade without a weekend birthday.

4.5 How the birthday countdown is calculated

The countdown finds your next anniversary after the reference date and counts the calendar days between. If today is your birthday it reads zero rather than jumping to next year, which is the behaviour people expect. The one genuine edge case is a 29 February birthday in a common year, where there is no anniversary to count to, so the tool uses whichever observed date you selected.

4.6 What the milestone table is for

Milestone ages carry real consequences: 18 for adulthood in most countries, 21 for some licences, 65 or 67 for pensions, and various thresholds in between for driving, voting and insurance. The table gives you the exact date each one lands on and the weekday, so you can plan around it rather than discovering it. The dates are exact anniversaries, not approximations from days.

4.7 Age in months, and when it matters more than years

For a child under two, years are almost useless. A 12 month old and a 23 month old are both one, and they are entirely different children. That is why paediatric growth charts, vaccination schedules and developmental milestones are all indexed on months, and why the calculator reports total months alongside years. Above about age three, months stop carrying extra information for most purposes.

4.8 What to do next with your result

Three practical moves come out of any age calculator result. If you needed the age for a form, use the years figure only and note the reference date you used, because an age without a date is meaningless a month later. If you are checking eligibility, set the age as of field to the official cutoff date rather than today. And if you are working with a whole spreadsheet of birth dates, copy the Excel formula in Section 8 rather than running this tool repeatedly.

4.9 Common mistakes this age calculator prevents

• Dividing total days by 365, which drifts by a day for every four years lived.
• Subtracting birth year from current year and forgetting to check whether the birthday has passed, which makes almost half of all people a year too old.
• Treating a 29 February birthday as invalid in a common year rather than choosing an observed date.
• Reading a spreadsheet date that was stored as text, so the arithmetic silently fails or returns an error.
• Mixing day-month-year and month-day-year formats, which turns 03/04/1990 into two different birthdays.
• Using age today when the rule asks for age on a fixed cutoff date.

4.10 What this result does not tell you

It does not tell you whether an age qualifies you for anything, because that depends on a rule written somewhere else. It does not know local conventions such as East Asian age reckoning. It carries no time of day, so someone born at 23:50 and someone born at 00:10 the next morning are treated as a full day apart. And it makes no claim about life expectancy, which is a population statistic and says nothing about any individual.

▶ Run the calculator above to auto-fill all five templates with your own dates.

The worked example carried through all ten steps is: born 15 June 1995, measured on 30 August 2026, giving 31 years, 2 months and 15 days.

1. Enter your date of birth. The field is pre-filled with 15 June 1995 so the page is never blank. Click the calendar icon or type the date directly.
2. Check the age as of date. It defaults to today. Leave it alone for your current age, or change it to a past or future date to see your age then.
3. Press Calculate Age. The result panel shows 31 years old, the life stage badge, and your position on the 0 to 100 bar.
4. Read the years, months and days. Section 2 leads with the full exact age. The years figure is the one to put on a form; the months and days say where you are inside your current year of life.
5. Look at the total days lived. The stat cards give 11,399 days, 1,628 weeks and 3 days, 374 months and 273,576 hours, all counted from real calendar days rather than estimated.
6. Check the birth weekday. 15 June 1995 was a Thursday. This is worth a glance because a wrong weekday is the fastest sign you typed the wrong year.
7. Read the birthday countdown. 289 days to go, landing on a Tuesday. If today is your birthday it reads zero.
8. Open the milestone table. It lists the exact dates you turn 18, 21, 30, 40, 50, 60, 65 and 70, with the weekday and whether each has passed.
9. Set the leap day rule if you need it. For a 29 February birthday, choose whether it is observed on 1 March or 28 February in common years. Your exact age does not change either way.
10. Copy or export. Copy Result gives one sentence, Download TXT the short file, and Download Doc and Download PDF the whole breakdown including the milestone table.

Excel has exactly one function that gives a true calendar age, and it is the one Microsoft hides. DATEDIF does not appear in the function list, gets no tooltip as you type it, and is documented only as a compatibility function, yet it works in every version of Excel and in Google Sheets. It is the correct tool, and everything else people reach for is an approximation.

8.1 The functions you need

8.2 Step by step

8.3 The awkward cases

A 29 February date of birth. DATEDIF handles it correctly for the years: someone born on 29 February 2004 is 22 on 30 August 2026. The problem is the next birthday formula, because =DATE(2027,2,29) silently returns 1 March 2027. That is Excel choosing the roll-forward convention for you. If your rule says 28 February, you have to test for it explicitly.

The date of birth is later than the reference date. DATEDIF returns #NUM! rather than a negative age, which is the right behaviour: a person cannot have a negative age. Guard the formula with =IF(A2>B2,"check dates",DATEDIF(A2,B2,"Y")) when you are running it down a column of imported data.

Blank cells. An empty A2 is read as zero, which Excel treats as 0 January 1900, producing an age of 126 years and no error at all. This is the single most dangerous case in a spreadsheet of ages, because nothing looks broken. Always guard with =IF(A2="","",DATEDIF(A2,TODAY(),"Y")).

Dates before 1900. Excel cannot store them as dates in the 1900 system, so anyone born before 1 January 1900 cannot be aged with DATEDIF. This calculator handles 1900 onwards for the same practical reason.

TODAY() recalculates. A sheet of ages built on TODAY() changes every time it is opened, which is usually what you want and occasionally a disaster when the sheet is a dated record. If the age is part of a record, replace the formula with its value once.

8.4 Why your Excel answer might differ from R or Python

Note the SQL Server row, which is the classic trap. DATEDIFF(year, '2025-12-31', '2026-01-01') returns 1, because it counts year boundaries crossed rather than completed years. Someone born yesterday would be reported as one year old on new year's day.

8.5 Charting ages in Excel

1. Put your ages in one column and the labels in the column beside them.
2. For a distribution, select the age column and use Insert → Charts → Histogram, then set the bin width to 5 or 10 years in Format Axis.
3. For an age pyramid, split the ages by group, make one group negative, and use a stacked bar chart with the axis labels moved to the low position.
4. Set the axis number format to 0 so ages never display as decimals.
5. Label the axis with the reference date the ages were computed on. An unlabelled age chart is undated and therefore unreadable a year later.

Chart 2 in Section 2 of this page already plots your milestone ages against the years remaining, which is usually the view people actually want.

8.6 Excel errors you will probably hit

Google Sheets: every formula in this section works unchanged, including DATEDIF, YEARFRAC, EDATE and TEXT. Sheets counts from 30 December 1899 and has no 1900 leap year bug, so the two agree on every birth date after March 1900.

Base R has no age function. A Date is a number of days, so ref - dob gives you total days immediately, but turning that into completed years, months and days needs the borrow logic written out. The script below does exactly that using base R only, so there is nothing to install, and every function it uses is documented in the base R date reference.

9.1 The complete script

R, base only, saves age_plot.png

# ============================================================
# Age from a date of birth, complete worked example
# Base R only. Prints a plain-English verdict and saves one
# 300 dpi figure called age_plot.png
# ============================================================

# ---- 1. YOUR DATA: change only these two lines ---------------
dob <- as.Date("1995-06-15")     # date of birth
ref <- as.Date("2026-08-30")     # measure the age on this date
# ref <- Sys.Date()              # uncomment for the age right now
# -------------------------------------------------------------

# Alternative: read a column of birth dates from a CSV
# dat <- read.csv("people.csv", stringsAsFactors = FALSE)
# dat <- dat[!is.na(dat$dob), ]            # drop missing values
# dob <- as.Date(dat$dob[1])

if (dob > ref) stop("The date of birth is after the reference date.")

days_in_month <- function(y, m) {
  as.integer(format(seq(as.Date(sprintf("%04d-%02d-01", y, m)),
                        by = "month", length.out = 2)[2] - 1, "%d"))
}

exact_age <- function(d1, d2) {
  p1 <- as.POSIXlt(d1); p2 <- as.POSIXlt(d2)
  y <- (p2$year - p1$year)
  m <- (p2$mon  - p1$mon)
  d <- (p2$mday - p1$mday)
  if (d < 0) {                                  # borrow a month
    m  <- m - 1
    pm <- if (p2$mon == 0) 12 else p2$mon
    py <- if (p2$mon == 0) p2$year + 1899 else p2$year + 1900
    d  <- d + days_in_month(py, pm)
  }
  if (m < 0) { y <- y - 1; m <- m + 12 }        # borrow a year
  c(years = y, months = m, days = d)
}

is_leap <- function(y) (y %% 4 == 0 & y %% 100 != 0) | (y %% 400 == 0)

a           <- exact_age(dob, ref)
total_days  <- as.integer(ref - dob)
total_months<- a["years"] * 12 + a["months"]
yrs         <- seq(as.integer(format(dob, "%Y")), as.integer(format(ref, "%Y")))
feb29       <- as.Date(paste0(yrs[is_leap(yrs)], "-02-29"))
leap_days   <- sum(feb29 >= dob & feb29 <= ref)

next_birthday <- function(d1, d2) {
  for (y in c(as.integer(format(d2, "%Y")), as.integer(format(d2, "%Y")) + 1)) {
    m  <- as.integer(format(d1, "%m")); dd <- as.integer(format(d1, "%d"))
    if (m == 2 && dd == 29 && !is_leap(y)) { m <- 3; dd <- 1 }
    b <- as.Date(sprintf("%04d-%02d-%02d", y, m, dd))
    if (b >= d2) return(b)
  }
}
nb   <- next_birthday(dob, ref)
wait <- as.integer(nb - ref)

cat("Date of birth   :", format(dob, "%A %d %B %Y"), "\n")
cat("Age as of       :", format(ref, "%A %d %B %Y"), "\n")
cat("Exact age       :", a["years"], "years,", a["months"], "months,", a["days"], "days\n")
cat("Total days lived:", format(total_days, big.mark = ","), "\n")
cat("Total weeks     :", total_days %/% 7, "weeks and", total_days %% 7, "days\n")
cat("Total months    :", total_months, "\n")
cat("Total hours     :", format(total_days * 24, big.mark = ","), "\n")
cat("Leap days lived :", leap_days, "\n")
cat("Next birthday   :", format(nb, "%A %d %B %Y"), "in", wait, "days\n")
cat("\nVERDICT: this person is", a["years"], "years old, and has lived",
    format(total_days, big.mark = ","), "days including", leap_days, "leap days.\n")

# ---- 2. FIGURE: one 300 dpi PNG -----------------------------
marks  <- c(18, 21, 30, 40, 50, 60, 65, 70)
dd     <- as.integer(format(dob, "%d")); mm <- as.integer(format(dob, "%m"))
if (mm == 2 && dd == 29) dd <- 28
mdates <- as.Date(sprintf("%04d-%02d-%02d", as.integer(format(dob, "%Y")) + marks, mm, dd))
gap    <- as.numeric(mdates - ref) / 365.2425
cols   <- ifelse(gap < 0, "#94a3b8", "#16a34a")

png("age_plot.png", width = 9, height = 5, units = "in", res = 300)
par(mar = c(4.5, 5.5, 3.5, 2))
bp <- barplot(rev(gap), horiz = TRUE, col = rev(cols), border = "#1e3a8a",
              names.arg = rev(marks), las = 1,
              xlim = c(min(gap) - 8, max(gap) + 12),
              xlab = paste("Years from", format(ref, "%d %B %Y"), " (negative = already passed)"),
              ylab = "Milestone age", main = "Age milestones", col.main = "#1e3a8a")
text(rev(gap) + ifelse(rev(gap) >= 0, 0.8, -0.8), bp, format(rev(mdates), "%d %b %Y"),
     adj = ifelse(rev(gap) >= 0, 0, 1), cex = 0.8, col = "#1f2937")
abline(v = 0, col = "#1e3a8a", lwd = 1.4)
dev.off()
cat("\nSaved age_plot.png at 300 dpi\n")

9.2 What each part of the script does

9.3 What the figure shows

The script writes age_plot.png to your working directory. It is a horizontal bar chart of the milestone ages, 18 through 70, drawn as years from the reference date. Bars to the left of the zero line are milestones already passed and are drawn grey; bars to the right are still ahead and are drawn green. The exact calendar date of each milestone is printed at the end of its bar.

Read it as a planning view rather than a result. The useful information is the calendar date on each bar, because that is the day the threshold is actually crossed.

9.4 Problems and fixes

9.5 One-liners worth remembering

The shortest correct answer in Python is relativedelta from the dateutil package: relativedelta(ref, dob).years gives completed years, with .months and .days for the rest. The standard library's timedelta deliberately has no year or month unit, as the timedelta documentation explains, because neither has a fixed length. The script below writes the borrow out by hand so it runs with no third-party package at all, and it produces exactly the same numbers as the R script above.

10.1 The complete script

Python 3, standard library plus matplotlib, saves age_plot.png

# ============================================================
# Age from a date of birth, complete worked example
# Prints a plain-English verdict and saves one 300 dpi figure
# ============================================================
from datetime import date, timedelta
import calendar
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

# ---- 1. YOUR DATA: change only these two lines ---------------
dob = date(1995, 6, 15)          # date of birth
ref = date(2026, 8, 30)          # measure the age on this date
# ref = date.today()             # uncomment for the age right now
# -------------------------------------------------------------

# Alternative: read a column of birth dates from a CSV
# import pandas as pd
# df = pd.read_csv("people.csv", parse_dates=["dob"])
# df = df.dropna(subset=["dob"])            # drop missing values
# dob = df["dob"].iloc[0].date()

if dob > ref:
    raise ValueError("The date of birth is after the reference date.")

def exact_age(d1, d2):
    """Completed years, then months, then leftover days."""
    y = d2.year - d1.year
    m = d2.month - d1.month
    d = d2.day - d1.day
    if d < 0:                                  # borrow a month
        m -= 1
        pm = d2.month - 1 or 12
        py = d2.year if d2.month > 1 else d2.year - 1
        d += calendar.monthrange(py, pm)[1]
    if m < 0:                                  # borrow a year
        y -= 1
        m += 12
    return y, m, d

years, months, days = exact_age(dob, ref)
total_days = (ref - dob).days
total_months = years * 12 + months
leap_days = sum(1 for y in range(dob.year, ref.year + 1)
                if calendar.isleap(y) and dob <= date(y, 2, 29) <= ref)

# next birthday, rolling a 29 February birth to 1 March in a common year
def next_birthday(d1, d2):
    for y in (d2.year, d2.year + 1):
        m, dd = d1.month, d1.day
        if m == 2 and dd == 29 and not calendar.isleap(y):
            m, dd = 3, 1
        b = date(y, m, dd)
        if b >= d2:
            return b
nb = next_birthday(dob, ref)
wait = (nb - ref).days

print("Date of birth   :", dob.strftime("%A %d %B %Y"))
print("Age as of       :", ref.strftime("%A %d %B %Y"))
print("Exact age       :", years, "years,", months, "months,", days, "days")
print("Total days lived:", format(total_days, ","))
print("Total weeks     :", total_days // 7, "weeks and", total_days % 7, "days")
print("Total months    :", total_months)
print("Total hours     :", format(total_days * 24, ","))
print("Leap days lived :", leap_days)
print("Next birthday   :", nb.strftime("%A %d %B %Y"), "in", wait, "days")
print()
print("VERDICT: this person is", years, "years old, and has lived",
      format(total_days, ","), "days including", leap_days, "leap days.")

# ---- 2. FIGURE: one 300 dpi PNG -----------------------------
marks = [18, 21, 30, 40, 50, 60, 65, 70]
dates = [date(dob.year + k, dob.month, dob.day if not (dob.month == 2 and dob.day == 29) else 28)
         for k in marks]
gap = [(d - ref).days / 365.2425 for d in dates]
colors = ["#94a3b8" if g < 0 else "#16a34a" for g in gap]

fig, ax = plt.subplots(figsize=(9, 5))
bars = ax.barh([str(k) for k in marks], gap, color=colors,
               edgecolor="#1e3a8a", linewidth=0.8)
for bar, d, g in zip(bars, dates, gap):
    off = 0.6 if g >= 0 else -0.6
    ax.text(g + off, bar.get_y() + bar.get_height() / 2, d.strftime("%d %b %Y"),
            va="center", ha="left" if g >= 0 else "right", fontsize=9, color="#1f2937")
ax.axvline(0, color="#1e3a8a", linewidth=1.4)
ax.set_xlabel("Years from " + ref.strftime("%d %B %Y") + "  (negative = already passed)")
ax.set_ylabel("Milestone age")
ax.set_title("Age milestones", fontsize=13, color="#1e3a8a")
ax.invert_yaxis()
ax.spines[["top", "right"]].set_visible(False)
fig.tight_layout()
fig.savefig("age_plot.png", dpi=300)
print("\nSaved age_plot.png at 300 dpi")

10.2 What each part of the script does

10.3 What the figure shows

The chart written to age_plot.png is identical in content to the R figure in section 9.3: one horizontal bar per milestone age, grey for milestones already passed, green for those still ahead, with the exact calendar date printed at the end of each bar. Run both scripts on the same date of birth and the two PNGs carry the same dates.

10.4 Problems and fixes

10.5 One-liners worth remembering

11.1 Age in every unit, for a person born 15 June 1995

Conclusion: years and total days are the two numbers worth recording. Everything else in this table is derived from them, and the last row of the list is an error rather than a unit.

11.2 Total days lived at each round age

Conclusion: the shortfall column is exactly the leap day count. That is the whole reason multiplying years by 365 fails, and it grows by one day every four years without exception until a non-leap century year.

11.3 What age you are on a given birth year, as of 2026

Conclusion: two people born in the same year differ in age by a full year for part of every year. This is why a birth year on its own is never enough to establish an age, and why forms ask for a full date of birth.

11.4 The Excel DATEDIF unit codes

Conclusion: the first four codes are dependable. Microsoft itself warns that "MD" can return a negative or inaccurate result, so compute leftover days by subtracting an EDATE offset when the exact figure matters. As of 2026, DATEDIF is still present in every Excel version despite being absent from the function list.

11.5 When your birthday falls, 2026 to 2040

Conclusion: the weekday advances by one each common year and by two across a leap year, so it returns to the same day after 5, 6 or 11 years rather than every 7. Reading down the weekday column shows that pattern directly.

11.6 Leap day birthdays, 2024 to 2044

Conclusion: a leap day baby gets a real birthday once every four years and an observed one in between. The exact age in years, months and days is identical under either convention. Only the countdown to the next birthday changes.

11.7 Common age thresholds and what they usually govern

Conclusion: every threshold in this table varies by country and scheme, and several have been changing upward. Treat the ages as typical rather than authoritative, and confirm the current rule with the official source before relying on any of them. Figures as of 2026.

An age calculator has only two inputs, and both are read off a document. Almost every wrong age traces back to one of them being misread rather than to the arithmetic.

1. Take the date of birth from a document, not from memory. Use the passport, birth certificate or official record. People routinely misremember a parent's or child's birth year by one.
2. Check the date order before you type it. 03/04/1990 is 3 April in the UK, India and most of Europe, and 4 March in the United States. If the source is ambiguous, look for another date in the same document with a day above 12, which settles the order at once.
3. Write it in ISO form as you go. Recording 1990-04-03 in your notes removes the ambiguity permanently and matches what every field on this page expects.
4. Verify against the weekday. If the person knows they were born on a Saturday and the calculator says Wednesday, the year or the month is wrong. This one check catches more typos than any other.
5. Decide which reference date the rule wants. Today, a scheme cutoff, the first day of a school year, or a policy start date are all different, and they give different ages.
6. Handle 29 February deliberately. If the date of birth is a leap day, choose the observed date rule before you calculate, and record which one you used.
7. Watch for spreadsheet text dates. A date that sits on the left of a cell is text, and the age formula will either error or silently skip it. Fix the column before you compute anything.
8. Guard against blank rows. An empty cell reads as zero, which is 0 January 1900, and produces an age of about 126 with no error at all. This is the most dangerous failure in a sheet of ages, because nothing looks broken.
9. Record the reference date beside every age. An age with no date attached is wrong within a year and unverifiable immediately.
10. Sanity check the extremes. Sort a column of computed ages and look at the top and bottom. Anything under 0 or over about 115 is almost certainly a data error rather than a person.

Dates are entered through the browser's own date control, which rejects impossible dates such as 31 February before the calculator ever sees them.

Common mistakes when gathering the inputs:

• Using today's date when the rule names a fixed cutoff.
• Copying a birth date from a spreadsheet cell that displayed a different format from the value it held.
• Typing a two digit year, so 65 becomes 2065 rather than 1965.
• Reading a birth year from a document that recorded age rather than date of birth.
• Assuming a leap day birthday is invalid and shifting it permanently to 1 March in the record itself.
• Storing an age instead of a date of birth, which goes stale the moment it is written down.

Use this age calculator when:

• ✓ You need an exact age in years, months and days from a date of birth.
• ✓ You need the total days, weeks, months or hours someone has lived.
• ✓ You are checking an age against a threshold on a specific cutoff date.
• ✓ You need the weekday of a birth date, or a countdown to the next birthday.
• ✓ The date of birth is 29 February and you need it handled properly.
• ✓ You want the same calculation as an Excel formula or an R or Python script to run over a whole column.

Do not use it when:

• ✗ You need a legal determination of eligibility. Use the number here to prepare, then confirm against the rule that applies.
• ✗ You need East Asian age reckoning or any non-Gregorian calendar.
• ✗ Time of day matters, for example for twins born either side of midnight.
• ✗ You need gestational or corrected age for a premature infant, which is measured from the due date, not the birth date.
• ✗ You want a life expectancy estimate. That is a population statistic and says nothing about an individual.
• ✗ The date of birth is before 1900, which is outside the supported range.

Four worked situations where an age calculator earns its place:

Four worked situations:

1. Filling in a form. Born 15 June 1995, on 30 August 2026: enter 31. Record the date the age was taken.
2. A school entry cutoff. Set the age as of field to the cutoff date named in the policy, not to today, and read the years figure.
3. A baby's clinic appointment. Use the months and days, or the total days. Years are meaningless below age two.
4. Pension planning. Put the scheme's pension age into the milestone view and read the exact date, then confirm the current pension age with the scheme.

Assumptions

1. Age is counted from the day of birth, in completed years. If it fails, for example under a rule that attains an age on the day before the anniversary, every result is one day late.
2. The Gregorian calendar applies throughout. If it fails, dates before 1583 shift by up to 13 days, which is why the tool starts at 1900.
3. The month borrow is taken from the month before the reference month. If your rule borrows differently, the months and days can be one day out. The years are never affected.
4. A 29 February birthday is observed on the date you selected. If it fails, the birthday countdown is one or two days out. The exact age is unaffected.
5. Dates carry no time of day. If it fails, someone born at 23:50 and someone born at 00:10 the next morning are treated as a day apart when they are twenty minutes apart.
6. The date of birth is correct. If it fails, everything downstream is wrong in a way no arithmetic can detect. The weekday check in Section 13 is the cheapest defence.
7. A day is 24 hours. If it fails, the hours and minutes figures drift by an hour twice a year wherever daylight saving applies.

Limitations

• It makes no eligibility determination. Legal thresholds for adulthood, pensions, licences and school entry are set by law and vary by country and scheme. Confirm the rule with the official source.
• It uses the international age convention only. East Asian age reckoning, which counted a newborn as one year old, is not supported. South Korea moved to the international system in June 2023.
• It supports the Gregorian calendar only. For Hijri, Hebrew, Persian or Japanese imperial dates you need a calendar conversion tool first.
• It handles whole days only, with no time of day and no time zones.
• It does not compute gestational or corrected age for premature infants, which is measured from the due date rather than the birth date and is a different calculation.
• It says nothing about life expectancy. The position bar is a display scale from 0 to 100, not a prediction about anyone.
• Dates before 1 January 1900 are outside the supported range, matching the practical limit of spreadsheet date systems.

An age calculator looks like the simplest tool on any site, and it hides two traps that catch people constantly. The first is forgetting to check whether the birthday has happened yet this year, which makes roughly half the population a year too old. The second is dividing days by 365, which quietly overstates age by a day for every four years lived and turns a 77 year old into a 78 year old on a spreadsheet.

Both traps have the same cure: count completed periods rather than estimating them. Completed years, then completed months, then the days left over. That is what official forms mean by age, what Excel's DATEDIF computes, and what the scripts in Sections 9 and 10 reproduce exactly. It also explains why two calculators can hand you months and days a day apart while agreeing perfectly on the years, and why the years figure is the only part any rule actually tests.

Record the reference date alongside every age you write down. An age with no date attached is stale within a year and unverifiable immediately, which is why records should store a date of birth and compute the age on demand rather than storing the age itself. The same habit protects you when a threshold is tested on a fixed cutoff rather than on today.

For very young children, drop the years entirely. A twelve month old and a twenty three month old are both one year old and are completely different children, which is why growth charts, vaccination schedules and developmental milestones are all indexed on months. The calculator reports every unit precisely so you can pick the one your context needs rather than rounding away the signal.

Use the age calculator at the top of this page whenever you need an exact age, set the age as of field to a cutoff date when you are testing eligibility, and copy the Excel, R or Python version from Sections 8 to 10 when you need to run the same calculation down a whole column of birth dates.

Twenty peer-reviewed journal articles on calendars, date representation, age measurement and date handling in software and research data. Standards documents and official age thresholds are named in Section 11 rather than here.

1. Dershowitz, N., & Reingold, E. M. (1990). Calendrical calculations. Software: Practice and Experience, 20(9), 899-928. https://doi.org/10.1002/spe.4380200905
2. Reingold, E. M., Dershowitz, N., & Clamen, S. M. (1993). Calendrical calculations, II: Three historical calendars. Software: Practice and Experience, 23(4), 383-404. https://doi.org/10.1002/spe.4380230404
3. Fliegel, H. F., & Van Flandern, T. C. (1968). A machine algorithm for processing calendar dates. Communications of the ACM, 11(10), 657. https://doi.org/10.1145/364096.364097
4. Richards, E. G. (2013). Calendars and their reform. Astronomy & Geophysics, 54(3), 3.28-3.30. https://doi.org/10.1093/astrogeo/att088
5. Allen, J. F. (1983). Maintaining knowledge about temporal intervals. Communications of the ACM, 26(11), 832-843. https://doi.org/10.1145/182.358434
6. Bettini, C., Jajodia, S., & Wang, X. S. (1998). A general framework for time granularity and its application to temporal reasoning. Annals of Mathematics and Artificial Intelligence, 22(1), 29-58. https://doi.org/10.1023/A:1018938900494
7. Dyreson, C. E., Evans, W. S., Lin, H., & Snodgrass, R. T. (2000). Efficiently supporting temporal granularities. IEEE Transactions on Knowledge and Data Engineering, 12(4), 568-587. https://doi.org/10.1109/69.868908
8. Snodgrass, R. T., & Ahn, I. (1986). Temporal databases. Computer, 19(9), 35-42. https://doi.org/10.1109/MC.1986.1663327
9. Jensen, C. S., & Snodgrass, R. T. (1999). Temporal data management. IEEE Transactions on Knowledge and Data Engineering, 11(1), 36-44. https://doi.org/10.1109/69.755613
10. Ohlbach, H. J., & Gabbay, D. (1998). Calendar logic. Journal of Applied Non-Classical Logics, 8(4), 291-324. https://doi.org/10.1080/11663081.1998.10510949
11. Wang, X. S., Bettini, C., Brodsky, A., & Jajodia, S. (1997). Logical design for temporal databases with multiple granularities. ACM Transactions on Database Systems, 22(2), 115-170. https://doi.org/10.1145/249978.249979
12. Combi, C., Franceschet, M., & Peron, A. (2004). Representing and reasoning about temporal granularities. Journal of Logic and Computation, 14(1), 51-77. https://doi.org/10.1093/logcom/14.1.51
13. Goralwalla, I. A., Leontiev, Y., Ozsu, M. T., Szafron, D., & Combi, C. (2001). Temporal granularity: Completing the puzzle. Journal of Intelligent Information Systems, 16(1), 41-63. https://doi.org/10.1023/A:1008737019055
14. Terenziani, P., & Snodgrass, R. T. (2004). Reconciling point-based and interval-based semantics in temporal relational databases. IEEE Transactions on Knowledge and Data Engineering, 16(5), 540-551. https://doi.org/10.1109/TKDE.2004.1277816
15. Strotgen, J., & Gertz, M. (2013). Multilingual and cross-domain temporal tagging. Language Resources and Evaluation, 47(2), 269-298. https://doi.org/10.1007/s10579-012-9179-y
16. Verhagen, M., Sauri, R., Caselli, T., & Pustejovsky, J. (2013). Temporal expression recognition and normalization. Language Resources and Evaluation, 47(1), 123-152. https://doi.org/10.1007/s10579-012-9198-8
17. Kuh, D., Ben-Shlomo, Y., Lynch, J., Hallqvist, J., & Power, C. (2003). Life course epidemiology. Journal of Epidemiology and Community Health, 57(10), 778-783. https://doi.org/10.1136/jech.57.10.778
18. Kramer, M. S., Platt, R. W., Wen, S. W., Joseph, K. S., Allen, A., Abrahamowicz, M., Blondel, B., & Breart, G. (2001). A new and improved population-based Canadian reference for birth weight for gestational age. Pediatrics, 108(2), e35. https://doi.org/10.1542/peds.108.2.e35
19. de Onis, M., Onyango, A. W., Borghi, E., Siyam, A., Nishida, C., & Siekmann, J. (2007). Development of a WHO growth reference for school-aged children and adolescents. Bulletin of the World Health Organization, 85(9), 660-667. https://doi.org/10.2471/BLT.07.043497
20. Sperrin, M., Marshall, A. D., Higgins, V., Renehan, A. G., & Buchan, I. E. (2016). Body mass index relates weight to height differently in women and older adults. Journal of Public Health, 38(3), 607-610. https://doi.org/10.1093/pubmed/fdv067