A 1-year-old dog is about 15 in human years, not 7. A 2-year-old is about 24. After that, size is a parameter: a Chihuahua adds ~4 human years per calendar year, a Great Dane adds ~7.

I needed a birthday-in, human-years-out function for a public calculator. The AVMA has been saying the ×7 rule is inaccurate for years. AAHA publishes a size chart. The job was to turn that chart into code that is deterministic, testable, and honest about leap years.

Live version: Dog Age Calculator by Birth Date. Below is the core logic.

The model

Two outputs, not one:

1. Human-year equivalent — a piecewise function of decimal dog years and size

2. Life stage — Puppy → Junior → Adolescent → Adult → Mature Adult → Senior, with a size-dependent senior threshold

Size is not cosmetic. It only changes the slope after year 2, which is the part most “dog year” widgets get wrong.

type DogSize = "small" | "medium" | "large" | "giant";

const SIZE_CONFIG: Record<
  DogSize,
  { agingRate: number; seniorThreshold: number }
> = {
  small:  { agingRate: 4, seniorThreshold: 10 }, // < 20 lb
  medium: { agingRate: 5, seniorThreshold: 9  }, // 20–50 lb
  large:  { agingRate: 6, seniorThreshold: 8  }, // 51–90 lb
  giant:  { agingRate: 7, seniorThreshold: 6  }, // > 90 lb
};

Rates come from the size chart adapted from Dog Owner’s Home Veterinary Handbook (also on AAHA’s canine/feline age poster). Senior thresholds follow the 2019 AAHA Canine Life Stage Guidelines — roughly the last 25% of expected lifespan.

Birthday → decimal years

Do not subtract years. Count days, then divide by 365.25.

function daysBetween(a: Date, b: Date): number {
  return Math.round((b.getTime() - a.getTime()) / 86_400_000);
}

function toDogYears(birthDate: Date, today = new Date()): number {
  if (Number.isNaN(birthDate.getTime())) {
    throw new RangeError("Invalid birth date");
  }
  if (birthDate > today) {
    throw new RangeError("Birth date cannot be in the future");
  }
  return daysBetween(birthDate, today) / 365.25;
}

Why 365.25 instead of 365? A dog born 1 Mar 2020 is four calendar years old on 1 Mar 2024, but that span included a leap day. Integer-year subtraction hides it. Day-count does not.

today is injected so the function is testable. Freeze it in unit tests or you get flakes every midnight.

Human years across four growth segments

Puppies do not age linearly. Year one is steep, year two is still steep, then the curve flattens and splits by size.

0 ────── 0.5y ────── 1y ────── 2y ──────────►
0        10          15        24
         └── ×20 ─┘ └── ×10 ┘ └── ×9 ┘ └── ×rate(size)

function toHumanYears(dogYears: number, size: DogSize): number {
  if (dogYears < 0.5) {
    return Math.round(dogYears * 20); // 0 → 10
  }
  if (dogYears < 1) {
    return Math.round(10 + (dogYears - 0.5) * 10); // 10 → 15
  }
  if (dogYears < 2) {
    return Math.round(15 + (dogYears - 1) * 9); // 15 → 24
  }
  const { agingRate } = SIZE_CONFIG[size];
  return Math.round(24 + (dogYears - 2) * agingRate);
}

Worked examples, same birthday, different size:

Until age 2, size is unused. After age 2 it is the whole function. That is the bug in every * 7 widget: it applies one slope to a domain that needs four.

Boundary note: < 0.5 means exactly 6 months uses the second branch and lands on 10. Off-by-one on the comparator changes the 6-month result.

Life stage is a second function

Human years are a translation for owners. Care planning uses life stage. Senior starts at 6 for giant breeds and 10 for small ones, so the stage function has to take size too.

type LifeStage =
  | "Puppy"
  | "Junior"
  | "Adolescent"
  | "Adult"
  | "Mature Adult"
  | "Senior";

function toLifeStage(dogYears: number, size: DogSize): LifeStage {
  const days = dogYears * 365.25;
  const seniorAt = SIZE_CONFIG[size].seniorThreshold;

  if (days < 182.625) return "Puppy";       // < 6 months
  if (days < 365.25) return "Junior";       // < 1 year
  if (days < 730.5) return "Adolescent";    // < 2 years
  if (days < (seniorAt - 2) * 365.25) return "Adult";
  if (days < seniorAt * 365.25) return "Mature Adult";
  return "Senior";
}

A 7-year-old Mastiff is already Senior. A 7-year-old Pomeranian is still Mature Adult. Same dogYears, different size.

AAHA prefers clinical life stages over human-year math for medical decisions. Keep both in the API. Do not let the rounded “39 human years” drive vaccine or surgery timing.

Unknown birthday

Rescue math is the reverse: adoption date minus estimated age.

function birthDateFromAdoption(
  adoptionDate: Date,
  months: number,
  weeks: number,
): Date {
  if (months < 0 || months > 11) throw new RangeError("Months must be 0–11");
  if (weeks < 0 || weeks > 12) throw new RangeError("Weeks must be 0–12");

  const estimatedDays = months * 30.44 + weeks * 7;
  const birth = new Date(adoptionDate);
  birth.setDate(birth.getDate() - Math.round(estimatedDays));
  return birth;
}

30.44 is 365.25 / 12. After this, the rest of the pipeline is unchanged: you now have a Date and can run toDogYears.

What we did not ship

The 2019 UC San Diego epigenetic-clock paper fits Labrador DNA methylation with something like:

16 * Math.log(dogYears) + 31;

While based on solid research, it makes an impractical default for a general calculator. It is breed-specific, lab-based, and diverges from the chart vets and owners already know. We implemented the published size chart so a 2-year-old is 24 everywhere, not 42 from ln(2).

Tests worth writing

Inject today. Assert the breakpoints, not a random Tuesday.

const today = new Date("2026-06-08T12:00:00");

expect(toHumanYears(0.5, "medium")).toBe(10);
expect(toHumanYears(1, "medium")).toBe(15);
expect(toHumanYears(2, "medium")).toBe(24);
expect(toHumanYears(5, "medium")).toBe(39);
expect(toHumanYears(5, "giant")).toBe(45);
expect(toHumanYears(10, "small")).toBe(56);
expect(toHumanYears(10, "giant")).toBe(80);

expect(toLifeStage(5, "medium")).toBe("Adult");
expect(toLifeStage(5, "giant")).toBe("Mature Adult");

Also cover: invalid date, future date, leap-day birthday, and the < 0.5 vs <= 0.5 boundary.

The whole thing

function dogAgeFromBirthday(
  birthDate: Date,
  size: DogSize,
  today = new Date(),
) {
  const dogYears = toDogYears(birthDate, today);
  return {
    dogYears,
    humanYears: toHumanYears(dogYears, size),
    lifeStage: toLifeStage(dogYears, size),
  };
}

Three pure functions, one size table, no * 7.

If you want the UI wrapped around this - breed → size, milestone dates, adoption fallback - it is running here: https://dailycalcs.com/pets/dog-age-calculator-by-birth-date/.

Human-year equivalents are planning estimates, not a diagnosis. Sources: AAHA 2019 Canine Life Stage Guidelines, AAHA age poster, AVMA senior-pet guidance.