ForHosting KIT · Home, food & hobbies

Convert pet age to human years

A 3-year-old medium dog is about 29 in human years, not 21: early years count far more than later ones. Choose the species, and the size for a dog, to compare life stages on adoption cards or at home. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Age (years): 3
Species: Dog
Size: Medium

You get

Human years: 29

Pet owners, clinics, shelters, and content sites constantly ask how old a companion animal is in human years. The old myth of seven human years per pet year understates the first two years of life for dogs and cats and misleads people comparing a giant breed senior to a small-breed adult. This convert pet age to human years calculator accepts the animal's age in calendar years, a species from a closed supported list, and—for dogs—a size class, then applies standard segmented aging tables that front-load more human-equivalent years in early life and slower increments afterward.

How non-linear pet-to-human aging tables work

Linear rules such as multiply by seven are popular because they are easy to remember, but they do not match veterinary life-stage charts. Dogs and cats mature quickly: a one-year-old dog is roughly a mid-teen human, and a two-year-old is already a young adult, after which each additional calendar year maps to a smaller human increment that depends on adult body size.

Giant breeds pack more human-equivalent years into midlife than small breeds of the same calendar age, which is why this converter requires a size category for dogs—small, medium, large, or giant—before it will compute. Cats use a fixed three-segment chart: fifteen human years in the first year, nine more in the second, then about four human years for each year after two. Rabbits are often mapped with roughly twenty-one human years in year one and six per year thereafter.

Horses use a slower adult slope: about six and a half human years in each of the first two years, then two and a half per year. Guinea pigs and hamsters mature even faster on short lifespans, so their first-year weights are higher and later increments stay steep. Fractional ages such as one and a half years interpolate linearly within the active segment so a six-month puppy is not treated as a full adult year.

None of these formulas replace a clinical exam; they are educational and product-facing estimates for comparing life stages across species without inventing species-specific rules in every client app.

What you can do with it

Shelter and clinic life-stage displays

Convert intake ages for dogs by size class and for cats or small pets into human-equivalent years for adoption cards and education boards.

FAQ

Why is dog size required?

Standard dog charts weight early and midlife years differently by adult size.

What happens for an unrecognized species?

The engine does not invent a generic multiplier for unknown animals.

Is this the same as multiply by seven?

No. Early years count more than later years, and dogs differ by size class. Linear seven-year rules are rejected as inaccurate for life-stage comparison.

How old is a 5-year-old cat in human years?

About 36. A cat gets 15 human years in its first year, 9 more in its second and roughly 4 for each year after that, so 15 plus 9 plus 12.

Can I enter an age like six months?

Yes. Fractional ages work, so 0.5 means six months. The result is worked out within the current life stage, so a six-month puppy is not treated as a full adult year.

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

POSThttps://api.kit.forhosting.com/life/pet-age-human-years

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/life/pet-age-human-years \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"age_years":3,"species":"dog"}'

const res = await fetch("https://api.kit.forhosting.com/life/pet-age-human-years", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "age_years": 3,
    "species": "dog"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/life/pet-age-human-years",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "age_years": 3,
    "species": "dog"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/life/pet-age-human-years", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"age_years":3,"species":"dog"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"age_years":3,"species":"dog"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/life/pet-age-human-years", 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,
  "species": "dog"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "life.pet_age_human_years",
  "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

Per request$0.002

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

Results are deterministic and rounded for stable displays in widgets, SMS bots, and prepaid API clients. Unrecognized species fail with invalid_input instead of inventing a fake multiplier. The same pure module powers the free browser path and the API at $0.002 per successful item so marketing pages and production automation never disagree on a three-year medium dog.

Input contract, response fields, and error behaviour

For non-dog species size may be omitted; if supplied it is validated against the same enum but does not change the species formula. Example: a three-year medium dog yields fifteen plus nine plus five, or twenty-nine human years at one decimal. A five-year cat yields fifteen plus nine plus twelve, or thirty-six human years. POST a JSON body with age_years as a positive finite number of calendar years (aliases age, years, pet_age) and species as one of dog, cat, rabbit, horse, guinea_pig, or hamster (aliases animal, pet, kind). When species is dog, size is required and must be small, medium, large, or giant (aliases dog_size, weight_class). Optional decimals (alias precision) is an integer zero through two controlling human_years rounding; the default is one decimal place for readable displays. Missing age or species, non-finite numbers, ages outside the supported range, and dog requests without size all raise invalid_input before any conversion runs. Unrecognized species—including free-text breed names, wildlife labels, or typos—also raise invalid_input with a message that lists the supported set, so clients can surface a clear form error instead of a silent fallback. On success the body echoes age_years and species, includes size when applicable, returns human_years rounded half-up, a method tag naming the table family, and a short formula string summarizing the segment constants used. Pair the response with your own UI copy; this endpoint does not emit veterinary advice text beyond the numeric conversion and formula fields.

Where a multi-species human-years API earns its keep

Classroom biology demos and STEM kits can show why non-linear tables beat the seven-year myth without standing up a spreadsheet for every animal. Keep ages within ordinary companion ranges, require size for dogs, reject unknown species loudly, and you get reproducible life-stage numbers for landing pages, SDKs, and edge workers without reinventing aging tables in every language. Shelter intake tools and pet insurance funnels need one stable endpoint that can convert dog, cat, and small-pet ages without shipping separate calculators per species.

Integration use cases

SEO widgets and content tools

Power a free convert-pet-age-to-human-years page that matches the API result for multi-species queries beyond dog-only or cat-only calculators.

Bots and insurance funnels

Chat and quote flows send age, species, and dog size to a deterministic endpoint instead of hard-coding seven-year myths per channel.

Technical questions

How do I convert a pet's age to human years?

Send age_years and species (dog, cat, rabbit, horse, guinea_pig, or hamster). For dogs also send size: small, medium, large, or giant. The API returns human_years from segmented non-linear tables.

What does the pet age to human years converter cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free