Next leap year finder
From 2023 the next leap year is 2024, and from 1899 it is 1904, because 1900 has no February 29. Type a year and get the first leap year on or after it, plus how many years remain. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Year
- 2,023
- Leap year
- 2,024
- Years until
- 1
This next leap year finder takes a single integer calendar year and returns the soonest Gregorian leap year that is equal to or later than that year. Classic checks include 2023 mapping to 2024, an already-leap 2024 returning itself with zero years until, 1899 skipping the non-leap century 1900 and landing on 1904, and 1999 advancing to 2000 because that century year is divisible by four hundred. The engine uses only the deterministic Gregorian leap rule—divisible by four, except century years that are not divisible by four hundred—with pure integer arithmetic and no network calls, random sampling, or host clock.
How the year is read and how the leap rule stays reproducible
The value must be a whole integer: number types must pass Number.isInteger, bigint values are accepted when they fit the range, and strings must match an optional sign plus digits only with no decimal point or exponent. Leading or trailing spaces on strings are trimmed, but scientific notation, hex prefixes, and mixed tokens are rejected with a clear message. After parsing, the year must fall between 1 and 9999 inclusive, matching the declared limits used by other proleptic Gregorian helpers in this catalog.
Internally the engine tests the leap predicate leap if and only if the year is divisible by four and not a non-four-hundred century, or divisible by four hundred; if the input fails the test it increments year by one repeatedly until a leap year is found. Century edge cases are covered by the same rule: 1900 is not leap, so 1899 yields 1904, while 2000 is leap, so 1999 yields 2000.
Where next-leap-year arithmetic fits in planning, teaching, and software
Operations and product teams need the next leap year when a multi-year plan must include a February 29 capacity day, when a compliance window is defined relative to the next leap cycle, or when a demo calendar should land on a known leap year without hard-coding a table. Analysts building long-range cohort labels use the same move to mark the next year that will have two hundred sixty-six days rather than two hundred sixty-five, so annual metrics stay aligned.
Developers call the contract from scripts to generate deterministic test vectors for date libraries, to seed property checks that assert February length, or to satisfy product requirements that demand a pure integer leap step without host locale calendars. Pair it with next-weekday, day subtraction, or ISO week helpers when you need related calendar steps, and with other free deterministic tools when you are assembling a small lab of date utilities.
What you can do with it
Long-range planning and capacity
Find the next leap year on or after a project start so multi-year plans account for an extra calendar day without hard-coded leap tables.
Teaching the Gregorian century rule
Show students that 1900 is not leap while 2000 is, and that 2023 advances to 2024, with reproducible integer-only arithmetic.
FAQ
What does the next leap year finder cost?
It is free in your browser on this page.
Which rule decides whether a year is leap?
The Gregorian rule: a year is leap if divisible by 4, except century years (divisible by 100) that are not also divisible by 400. Examples: 2024 and 2000 are leap; 1900 and 2100 are not.
Why is 2023.5 rejected?
The year must be an integer whole number.
Does this return a full February 29 date?
Build YYYY-02-29 yourself if you need a full date string.
Why does 1899 lead to 1904 and not 1900?
Because 1900 is a century year that is not divisible by 400, so it has no leap day. The search skips it and lands on 1904, while 1999 goes straight to 2000, which does divide by 400.
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/next-leap-year \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"year":2023}'const res = await fetch("https://api.kit.forhosting.com/date/next-leap-year", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"year": 2023
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/date/next-leap-year",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"year": 2023
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/date/next-leap-year", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"year":2023}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"year":2023}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/date/next-leap-year", 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": 2023
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "date.next_leap_year",
"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.
Limits
year_min | 1 |
year_max | 9999 |
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
What next leap year means and what the response contains
Finding the next Gregorian leap year answers a different question from checking whether a single year is leap or computing February length for a fixed stamp: it walks forward from your starting year, applying the civil calendar leap predicate at each step, until a leap year is found or the supported range ends. You supply a year field as a whole integer; the engine rejects fractional values such as 2023.5, empty fields, and non-numeric tokens so a bad cell does not become a wrong answer. On-or-after semantics mean that if the input year is already a leap year, years_until is zero and leap_year equals year; otherwise years_until is the positive whole-year distance to the next leap. The calculator returns the normalized input year, the leap_year result, years_until, a boolean is_input_leap flag, a short English rule string, and a compact formula reminder of the predicate and the min-y-at-or-after definition. Rejected cases include a missing year, non-integers, values outside one through nine thousand nine hundred ninety-nine, and inputs that would require a leap year beyond the upper bound. If you need day-of-week math, full date construction with February 29, or age and interval tools, use those dedicated endpoints; this page answers only the next Gregorian leap year at or after a given year.
How the year is read and how the leap rule stays reproducible
The preferred field is year, but aliases y, from, start, and value are accepted so spreadsheets, query strings, and typed forms can reuse the same contract without renaming columns. Pair the free browser run on this page with the priced API when you need the identical next leap year inside an automated pipeline.
Where next-leap-year arithmetic fits in planning, teaching, and software
On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a one-off check to a pipeline without changing the mathematical result.
Integration use cases
Deterministic test fixtures
Generate next-leap-year integers for unit tests, property checks, and CI assertions without Date or the host clock.
Technical questions
If the input year is already a leap year, what is returned?
That same year. Semantics are on-or-after: years_until is 0, is_input_leap is true, and leap_year equals year.