SS claim breakeven calculator
Claim 1,800 a month at 62 or wait for 2,400 at 70? Added up month by month, the delayed claim only overtakes the early one at about age 94.08. Find your own breakeven age before you decide. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Monthly benefit for option A
- 1,800
- Monthly benefit for option B
- 2,400
- Claiming age for option A
- 62
- Claiming age for option B
- 70
- Annual cost-of-living adjustment (%)
- 0
- Months since option A begins
- 385
- Break-even age
- 94.08
- Cumulative benefits for option A
- 693,000
free
How the breakeven age is found
The calculator compares two ways of claiming. Strategy A pays a smaller benefit every month from an earlier age; strategy B pays a larger one, but only from a later age. Month by month it adds each payment to a running total for both strategies and stops at the first month in which the delayed total overtakes the early one. That month, counted from the first claiming age, gives the breakeven age. With 1,800 a month from 62 against 2,400 from 70 and no cost-of-living raise, the crossover comes after 385 months, at about 94.08, when the totals are 693,000 and 693,600.
What the breakeven age does and does not tell you
If you expect to live past the breakeven age, waiting pays more in total; if not, claiming early does. The comparison uses nominal monthly payments with no discounting, so it is not a present-value analysis. It also leaves out taxes and spousal benefits. Treat the age as one useful input to your decision, to be weighed against your own circumstances and plans.
FAQ
What does the breakeven age tell me?
Claiming early tends to win if you expect a shorter horizon; delaying wins for a longer one.
Does it account for taxes or spousal benefits?
No. It compares nominal monthly benefits only, with no taxes, discounting, spousal or survivor benefits, or mortality. Use it as one factor, not a full plan.
Can I include a yearly cost-of-living increase?
Yes, there is an optional annual cost-of-living percentage. Left at zero, the two monthly amounts are compared exactly as you enter them, which is how the example of 1,800 at 62 against 2,400 at 70 is run.
Why is the breakeven called nominal?
Because payments are simply added up month by month as they arrive, with no discounting. Money received at 62 counts the same as money received decades later, so the result is not a present-value comparison.
Which ages and amounts can I enter?
Both monthly benefits must be above zero, the earlier claiming age must be positive and the later one must be greater than it. The gap between the two ages is turned into months of delay, rounded to whole months.
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/finance/ss-claim-breakeven \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"benefit_a":1800,"benefit_b":2400,"age_a":62,"age_b":70}'const res = await fetch("https://api.kit.forhosting.com/finance/ss-claim-breakeven", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"benefit_a": 1800,
"benefit_b": 2400,
"age_a": 62,
"age_b": 70
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/finance/ss-claim-breakeven",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"benefit_a": 1800,
"benefit_b": 2400,
"age_a": 62,
"age_b": 70
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/finance/ss-claim-breakeven", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"benefit_a":1800,"benefit_b":2400,"age_a":62,"age_b":70}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"benefit_a":1800,"benefit_b":2400,"age_a":62,"age_b":70}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/finance/ss-claim-breakeven", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"benefit_a": 1800,
"benefit_b": 2400,
"age_a": 62,
"age_b": 70
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "finance.ss_claim_breakeven",
"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
Simulates two Social Security claiming strategies month by month — a smaller early benefit_a starting at age_a versus a larger delayed benefit_b starting at age_b — to find the breakeven age where cumulative_b overtakes cumulative_a, with an optional annual cola_percent. API from $0.002.
The month-by-month breakeven model
This capability answers a classic retirement question: claim a smaller Social Security benefit early or wait for a larger one? It runs a month-by-month accumulation rather than a closed-form ratio. Strategy A pays benefit_a every month starting at age_a; strategy B pays the larger benefit_b but only after age_b, expressed as monthsToB = round((age_b − age_a) × 12) months of delay. Each month the loop adds benefit_a to cumulative_a and, once past monthsToB, benefit_b to cumulative_b, stopping the first month cumulative_b exceeds cumulative_a. With benefit_a 1800 at age 62 and benefit_b 2400 at age 70 and no COLA, the crossover lands at months_from_a = 385, an age_breakeven of 94.08, where cumulative_a is 693000 and cumulative_b is 693600 — the delayed claim only pulls ahead if you live well into your nineties.
Inputs, COLA and rounding
Because benefits are compared as nominal monthly cash flows with no discounting, the tool reports a nominal breakeven, not a present-value one. Four numeric inputs are required: benefit_a and benefit_b must both be greater than zero, age_a must be positive, and age_b must be strictly greater than age_a. Any violation returns a typed invalid_input error naming the field, for example 'age_b inválido', so a form can highlight it. The optional cola_percent defaults to 0 and models an annual cost-of-living adjustment: every twelfth month both benefits are multiplied by (1 + cola_percent/100), so the raise compounds and applies equally to A and B. Outputs are months_from_a (the integer month of the crossover), age_breakeven (age_a + months/12, rounded half-up to two decimals), and cumulative_a and cumulative_b accumulated to two decimals.
Edge cases and what it ignores
Results deliberately ignore taxes, spousal and survivor benefits, investment of the early payments, and actual mortality, so treat the breakeven age as one input to a claiming decision rather than the whole answer. The simulation is capped at 120 years, 1440 months; if the larger benefit never overtakes the smaller within that window the tool raises invalid_input rather than looping forever, which happens when benefit_b barely exceeds benefit_a or the delay is very long. The model always defers the larger benefit — age_b must exceed age_a — matching the real trade-off where waiting buys a bigger monthly check. A positive cola_percent pushes the breakeven slightly later, because the same percentage raise adds more absolute dollars to the higher benefit, yet strategy A still has a head start of monthsToB months of payments to overcome.
Integration use cases
Retirement claiming decision
Estimate the age at which delaying Social Security to a larger benefit_b finally pays off versus claiming the smaller benefit_a early.
Advisor what-if batches
Call the API with many benefit, age and COLA combinations to build a breakeven table across a client's plausible claiming scenarios.
COLA sensitivity
Vary cola_percent to see how an annual cost-of-living raise shifts the crossover age later for someone weighing early against delayed claiming.
Technical questions
How is COLA applied?
cola_percent defaults to 0 and compounds annually — every 12th month both benefits are multiplied by (1 + cola_percent/100), applied equally to A and B.
Why must age_b be greater than age_a?
The model always defers the larger benefit_b to the later age_b; if the inputs do not satisfy age_b > age_a > 0 it returns a typed invalid_input error.
Is it free?
The tier-A widget is free in your browser; the deterministic API is billed from $0.002, and failed tasks are never charged.