Decade and century finder
2024 belongs to the 2020s, which run from 2020 to 2029, and to the 21st century, from 2001 to 2100. Enter any whole year, including negative years before the Common Era, and get both labels with their boundaries. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Year
- 2,024
- Decade
- 2,020
- Decade label
- 2020s
- Decade start
- 2,020
- Decade end
- 2,029
Knowing which decade and century a year belongs to sounds simple until you hit the edge cases that trip up spreadsheets and quick mental math. The year 2000 sits in the twentieth century, not the twenty-first; the 1990s run from 1990 through 1999; and negative years for Before Common Era need a clear, repeatable rule. This capability takes a single integer year and returns the decade window, human-readable labels such as 2020s or twenty-first century, inclusive start and end years, and the era (CE or BCE). Non-integer years fail with a clear invalid input error and are not charged.
How decades and centuries are defined from a year
The decade is the ten-year window whose start is year with the ones digit removed by floor division, so 2024 maps to the 2020s spanning 2020 through 2029, and 1999 maps to the 1990s. The ordinal century for positive Common Era years uses the classical rule century equals the ceiling of year divided by one hundred: years one through one hundred form the first century, years nineteen hundred one through two thousand form the twentieth, and years two thousand one through twenty-one hundred form the twenty-first.
That is why the year two thousand is still the twentieth century even though its decade label is the two-thousands. Negative years are treated as Before Common Era with the same absolute numbering, so year negative forty-four sits in the first century BCE. The engine accepts a wide safe integer range for historical and far-future timelines while still rejecting non-integers so the response never pretends a fractional year has a unique decade boundary.
What you can do with it
Timelines, museums, and content tools
Editors and exhibit builders map event years to decade and century labels for captions, filters, and dual-axis timelines without reimplementing ordinal century rules.
FAQ
What century is the year 2000?
The year 2000 is in the 20th century (1901–2000) and the 2000s decade (2000–2009). The 21st century starts at 2001.
What happens if the year is not an integer?
Non-integer years such as 2024.5 are rejected and not charged.
Is the decade and century finder free?
The browser tool runs free on your device.
Are BCE (negative) years supported?
Yes. Send a negative integer year for Before Common Era; the response sets era to BCE and labels the ordinal century accordingly.
How is the century of a year worked out?
Divide the year by 100 and round up. Years 1 to 100 form the first century, 1901 to 2000 the twentieth and 2001 to 2100 the twenty-first, which is why 2000 still closes the twentieth.
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/date/decade-century \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"year":2024}'const res = await fetch("https://api.kit.forhosting.com/date/decade-century", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"year": 2024
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/date/decade-century",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"year": 2024
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/date/decade-century", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"year":2024}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"year":2024}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/date/decade-century", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"year": 2024
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "date.decade_century",
"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
Everything is pure deterministic arithmetic with no network, no wall clock, and no floating-point guesswork, so homework checkers, museum timelines, genealogy tools, and curriculum generators can pin the JSON in tests.
How decades and centuries are defined from a year
Send the required field year as a JSON integer or an integer string; aliases y and yr are accepted when documented.
Reading the response fields and common mistakes
The era field is CE or BCE so downstream UIs can style labels without re-deriving the sign of the year. Use decade fields alone when building decade-filter chips; use century fields when labeling historical periods; use both when a timeline needs dual axes. On success the response echoes year and returns decade equal to decade_start, decade_end nine years later, and decade_label such as 2020s for display. Century is the ordinal number, century_ordinal adds the English suffix such as 21st, and century_label spells the full phrase including BCE when needed. Century_start and century_end give inclusive year bounds for that century under the same numbering so charts and captions stay aligned. Method is always decade_century so pipelines can branch without sniffing shapes. The most common mistake is assuming every year that starts with twenty is the twenty-first century; this endpoint answers that question explicitly for two thousand and for two thousand one so students and content editors see the difference. Another mistake is sending a full date string or a float such as two thousand twenty-four point five; those fail with invalid_input and never consume balance after the engine rejects the request.
API usage, pricing, classroom workflows, and practical limits
Call the free in-browser decade and century finder for homework checks, museum copy, lesson demos, and quick fact-checks without installing calendar libraries. Keep years within the published safe range for isolate safety and prefer classroom-scale CE years for grading oracles. Send a JSON body with the required integer year. Use the prepaid API when a genealogy platform, educational app, newsroom tool, or timeline generator needs a stable contract under KIT balance at $0.002 per successful item; validation failures never consume balance. Pair this endpoint with days-in-month or quarter tools when the next step is finer calendar structure, or with countdown helpers when you already know the target year and only need period labels. Authors shipping SDKs can map decade_label and century_label directly into UI badges—the same phrases people expect on Wikipedia-style timelines—while still having numeric bounds for sorting and filtering.
Integration use cases
Homework and exam verification
Students and graders check whether a year falls in the 1990s or the 21st century, and get a clear invalid_input error when a non-integer year is submitted by mistake.
Genealogy and curriculum pipelines
Scripts that tag birth years or historical units call a stable prepaid endpoint instead of duplicating floor/ceil century math in every language.
Technical questions
How do I find the decade and century for a year?
Send JSON with year set to an integer (for example year: 2024). The response includes decade_label (2020s), century_ordinal (21st), bounds, and era.