Dog age calculator
Turn your dog's age into human years on a curve set by its size, where a one-year-old medium dog is 15 and each year after the second adds 4 for small dogs and up to 7 for giant breeds. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Age (years)
- 1
- Size category
- Medium
- Equivalent human age
- 15
free online
Why a dog's age depends on its size
Unlike a cat, a dog ages at a pace that depends on its body size, so a single multiplier gets it wrong. The calculator uses three stages for each of four sizes: small, medium, large and giant. The first year counts as 15 human years for small and medium dogs, 14 for large dogs and 12 for giant breeds. The second year adds 9 for small, medium and large dogs, and 10 for giant ones. Every year after that adds 4 for small dogs, 5 for medium, 6 for large and 7 for giant breeds, reflecting how larger dogs age faster later in life. That is why a Chihuahua and a Great Dane drift so far apart after middle age.
How to read the result
A one-year-old medium dog comes out at 15 human years. Ages between whole years are spread evenly within their stage, so a medium dog of 18 months is about 19.5. The stages join exactly at one and two years, so the curve never jumps from one month to the next. You can enter any age above 0 and up to 30 years. Vets and breeders use this kind of estimate to give owners a size-accurate human age instead of the times-seven rule, and adoption profiles use it to show a giant breed's true life stage, so new owners can plan for its shorter timeline.
Size-specific ageing curves
Unlike a cat, a dog's ageing depends on body size, so the tool keys three lookup tables on size — small, medium, large or giant. The first year is worth 15 human years for small and medium dogs, 14 for large and 12 for giant breeds. The second year adds 9 for small, medium and large, and 10 for giant.
Each year beyond the second adds 4 for small, 5 for medium, 6 for large and 7 for giant, reflecting how larger dogs age faster later in life.
Why size matters and edge behaviour
Size matters because a Chihuahua and a Great Dane diverge sharply after middle age; a flat multiplier would overstate a small dog's age and understate a giant's later years. The segmented tables capture that difference without needing a per-breed database. The boundaries at exactly 1 and 2 years use less-than-or-equal comparisons, so the curve stays continuous with no jump.
What you can do with it
Vet and breeder sites
Give owners a size-accurate human-age estimate instead of the misleading times-seven rule.
Adoption profiles
Display a giant-breed dog's true life stage so adopters plan for its shorter timeline.
FAQ
Why does size matter?
Larger dogs age faster after year two, so the tool uses size-specific curves for small, medium, large and giant.
How is the first year counted?
15 human years for small and medium, 14 for large, 12 for giant; the second year adds 9, or 10 for giants.
How old is an 18-month-old dog in human years?
For a medium-sized dog, about 19.5 human years. Ages with fractions are spread evenly within each stage, so a dog halfway through its second year sits between the first-year and second-year values.
Is one dog year really seven human years?
No. A flat times-seven rule overstates a small dog's age and understates a giant breed's later years. Here each size has its own curve: after the second year, a small dog adds 4 human years per year and a giant dog 7.
Up to what age can I enter?
Any age greater than 0 and up to 30 years, including fractions such as one and a half. The result is the human-equivalent age for the size you pick.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/dev/dog-age \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"age_years":3,"size":"medium"}'const res = await fetch("https://api.kit.forhosting.com/dev/dog-age", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"age_years": 3,
"size": "medium"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/dog-age",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"age_years": 3,
"size": "medium"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/dog-age", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"age_years":3,"size":"medium"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"age_years":3,"size":"medium"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/dog-age", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"age_years": 3,
"size": "medium"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.dog_age",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
Converts a dog's age_years to human-equivalent years using a size-aware segmented curve (small, medium, large or giant), returning human_years and the size back as JSON.
Size-specific ageing curves
The code computes: for age of 1 or less, human = firstYear × age; for age of 2 or less, human = firstYear + secondYear × (age − 1); otherwise human = firstYear + secondYear + perYear × (age − 2). method in the output is segmented_apa_style.
Inputs, rounding and returned fields
Fractional ages interpolate linearly within each segment, so a size-medium eighteen-month dog maps to about 19.5 human years. Two fields are required: age_years, a finite number greater than 0 and at most 30, and size, which must be one of the four enum values small, medium, large or giant. The response is a JSON object with four keys: age_years and size echoed back, the computed human_years, and method set to segmented_apa_style.
Why size matters and edge behaviour
Validation runs first — a bad age, an out-of-range or non-integer decimals, or a size outside the enum all yield invalid_input naming the field at fault.
Integration use cases
Pet insurance
Use human_years and size to segment risk and time wellness reminders by life stage.
Technical questions
What sizes are accepted?
Exactly small, medium, large or giant. Any other value returns invalid_input.
Does it take fractional ages?
Yes, ages interpolate within each segment; age_years must be over 0 and at most 30.
Is it free?
Yes in the browser. The API uses prepaid KIT balance from $0.002; failed tasks are not charged.