Dating theory
At 30, the half-your-age-plus-seven rule gives a partner range of 22 to 46, a 24-year window. Enter a whole-number age to see both bounds of this folk rule; it is a conversation piece, never a legal standard. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Age
- 30
- Min age
- 22
- Max age
- 46
- Span
- 24
- Range
- 22-46
The half-your-age-plus-seven rule is a long-lived folk formula people reach for when a dating age gap comes up at dinner, in a group chat, or after a first date. This dating theory calculator takes one positive integer age in whole years and returns the youngest and oldest partner ages that mnemonic names: half the given age plus seven as the lower bound, and twice the quantity age minus seven as the upper bound. The output is a heuristic you can quote, not a legal opinion: local age-of-consent and marriage laws always take precedence over a dinner-table rule.
What half your age plus seven actually computes
The half-your-age-plus-seven rule is a two-sided folk formula, not a statute. For a person of age A in whole years, the youngest partner age the rule calls socially discussed is A divided by two, plus seven. The oldest partner age is the reciprocal of the same rule applied to the other person: twice the quantity A minus seven.
Together those two numbers are the dating age range this calculator returns, along with the span between them and a short display string of the form min-max. At age thirty the younger bound is twenty-two and the older bound is forty-six, a twenty-four-year window. At age twenty-five the younger bound is nineteen and a half and the older bound is thirty-six, because an odd whole age produces a half-year on the low side rather than a silent round.
At age fourteen the two sides meet: fourteen is both the minimum and the maximum, which is why fourteen is the algebraic fixed point of the mnemonic. Below fourteen the computed maximum falls below the computed minimum, so the interval is empty as a range even though both numbers remain well-defined. This capability still reports those two numbers so a caller can see the arithmetic instead of receiving a hidden clamp.
None of this is a legal standard. Age-of-consent statutes, marriage codes, and workplace policies are written by legislatures and employers, not by a parlor mnemonic, and they override the formula wherever they apply. Treat the range as a conversation starter you can recompute, not as permission.
Where a dating-range calculator earns its keep
Columnists, relationship blogs, and trivia sites all get the same search: half your age plus seven, dating age range, is this gap too large. Journalism desks use the same identity when they caption an age-gap story and need a number they can defend as the folk rule rather than as editorial taste.
Classroom lessons on functions, reciprocals, and fixed points can treat age fourteen as the meeting point of min and max and ask students to prove that max minus min equals one and a half times age minus fourteen—an identity this calculator makes checkable in one call. Keep requests small, pin the expected bounds in tests, and you get a reproducible dating-theory number for copy, lessons, and edge workers.
This page is not a substitute for judgment, legal counsel, or the age-of-consent law where you live; it is a deterministic map from one integer to a folk range.
What you can do with it
Check a dating age gap against the folk rule
Enter your age and read the youngest and oldest partner ages the half-your-age-plus-seven mnemonic names, including the reciprocal older bound.
Teach reciprocals and fixed points with a familiar rule
Show that the two sides meet at fourteen and that an odd age yields a half-year lower bound, then let students check their algebra against the same deterministic response.
FAQ
How does the dating theory calculator pick a min and max age?
Age thirty returns twenty-two to forty-six; age twenty-five returns 19.5 to thirty-six.
What happens if age is not a positive integer?
Missing, zero, negative, fractional, and non-numeric ages are rejected so the range is never invented from a bad input, and those failures are not billed.
Why can the maximum be smaller than the minimum?
Below age fourteen the reciprocal ceiling falls below the younger floor, so span is negative. The calculator still returns both numbers rather than clamping them, because that is what the arithmetic says.
Is this a legal dating age?
No. This is a folk social heuristic, not a statute. Age-of-consent, marriage, and workplace rules where you live always override the mnemonic. The result is a conversation number, not permission.
Why does an odd age give a half-year limit?
Because half of an odd number is not whole, and the result is shown as it is rather than rounded. At 25 the younger bound is 19.5 and the older bound is 36.
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/life/dating-theory \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"age":30}'const res = await fetch("https://api.kit.forhosting.com/life/dating-theory", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"age": 30
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/life/dating-theory",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"age": 30
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/life/dating-theory", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"age":30}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"age":30}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/life/dating-theory", 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": 30
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "life.dating_theory",
"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
max_age | 120 |
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
If the age is missing, zero, negative, or not a whole number, the task fails with invalid_input and is not billed. Successful API calls use prepaid balance at $0.002.
Input contract, errors, and the shape of the response
Zero and negative values fail the same way, because a dating range is not defined for a non-positive age. Ages above one hundred and twenty are rejected so a paste of a timestamp cannot be mistaken for a human age. Failed validation is not billed. POST a JSON body with the required field age, a positive integer in whole years. The parser also accepts years and age_years so form posts and older wrappers do not have to rename the field. The value may arrive as a JSON number, as a digit string such as "30", or as a bigint in range; fractional numbers, scientific notation, empty strings, booleans, objects, and arrays fail with invalid_input that names age. On success the body includes age, the echoed whole years; min_age, equal to age divided by two plus seven; max_age, equal to two times the quantity age minus seven; span, the signed difference max_age minus min_age; range, a display string joining the two bounds with a hyphen; formula, a short restatement of both identities; and rule, always half_your_age_plus_seven so clients can distinguish this contract from a later heuristic. Odd ages produce a half-year on min_age (nineteen point five at twenty-five) and an integer on max_age; even ages produce two integers. Pair the JSON with your own UI: a large range, the two bounds as labelled numbers, and a reminder that this is a folk rule rather than counsel. Successful API calls cost the published $0.002.
Where a dating-range calculator earns its keep
Product teams building icebreakers, party games, or onboarding quizzes can call a tiny parse endpoint instead of copying the two lines of arithmetic into five clients that then disagree on whether twenty-five floors to nineteen or twenty.
Integration use cases
Caption an age-gap story with a defensible number
Newsrooms and relationship blogs can quote min_age and max_age as the classic rule rather than as editorial taste, with a formula string they can print beside the range.
Technical questions
What does the dating theory calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.