ForHosting KIT · Finance & money

US income percentile calculator

A household income of 80,000 sits at the 50th percentile, right on the median: half of US households earn less. Enter any annual household income to see its national rank and the share above and below. 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

Income: 80,000

You get

Percentile: 50
Percentile rounded: 50
Rank: 50th
Share below: 50

A US household income percentile calculator answers the question that a raw salary never answers: given this annual household income, where does it sit among US households? Job offers, relocation debates, mortgage conversations, and personal-finance articles all quote a dollar figure, but that figure only becomes comparable once you know how many households earn less. This tool accepts a non-negative annual income in US dollars, looks it up on a fixed built-in household income distribution table, interpolates linearly between neighboring knots, and returns the percentile rank from zero through one hundred.

What a household income percentile tells you

A salary figure on its own says little about where a household stands. The percentile turns it into a share: the percentage of US households that earn less than that annual income. At the 50th percentile half of households earn less and half earn more, which is the median. The rank is about households, not individuals, so a home with two earners should enter the combined income of everyone in it. The figure helps when you compare job offers, weigh a move to another city or read a personal-finance article that quotes a salary without context.

How the rank is worked out, and common mistakes

The calculator holds a fixed table of household incomes and the percentile at each point. When your income falls between two points, it draws a straight line between them and reads the rank from that line, so a small change in income moves the rank smoothly. An income exactly on a point returns that point's percentile. A common mistake is entering one person's pay for a household with several earners, which understates the rank. Another is expecting the top of the scale to stretch forever: incomes above the last point stay at the last percentile.

How a built-in household income table becomes a percentile

The US household income distribution is a cumulative curve: at every dollar amount, some share of households earns less than that amount. That share, expressed from 0 through 100, is the percentile rank. Given an annual income, the solver finds the two neighboring knots that bracket it and interpolates linearly.

The identity is P equals P_lo plus the fraction (income minus I_lo) divided by (I_hi minus I_lo), times (P_hi minus P_lo). An income that lands exactly on a knot returns that knot's percentile with no interpolation. Income above the last tabulated knot is capped at the last tabulated percentile rather than inventing an unmeasured tail.

Income of zero maps to the 0th percentile.

What you can do with it

Job offers and relocation ranking

Turn an annual household figure into a national percentile before comparing offers, cities, or dual-income plans.

Personal-finance explainers

Publishers and journalists can attach a reproducible household rank next to a quoted salary instead of a vague rich-or-poor label.

FAQ

How is the US household income percentile calculated?

The solver looks up your annual income on a fixed built-in household CDF table and linearly interpolates between the two neighboring knots. An exact knot returns that knot's percentile; income above the last knot is capped at the last tabulated percentile.

Should I enter individual pay or household income?

Enter annual household income in US dollars, the quantity the built-in table describes. Individual wages can be entered, but the rank will still be read against the household distribution, not an earnings-by-worker table.

What happens if income is negative or missing?

Percentile rank is defined only for a non-negative finite number; missing, empty, NaN, Infinity, and negative values are not billed.

Is this live Census data for the current year?

No. It uses a fixed household income table built into the calculator, so the same income always returns the same rank. Treat the result as a reproducible reference point rather than a live statistic.

What happens with an income above the top of the table?

It is capped at the last percentile in the table instead of inventing a tail that was never measured. At the other end, an income of zero maps to the 0th percentile.

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/fin/us-income-percentile

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/fin/us-income-percentile \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"income":80000}'

const res = await fetch("https://api.kit.forhosting.com/fin/us-income-percentile", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "income": 80000
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/fin/us-income-percentile",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "income": 80000
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/us-income-percentile", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"income":80000}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"income":80000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/us-income-percentile", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "income": 80000
}

Example response

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

Limits

max_abs 1000000000000000

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

Missing income, negative income, and non-finite numbers fail with invalid_input and are not billed. Successful calls are billed at $0.002.

Input contract, error behaviour, and the response shape

Magnitudes above the published limit also fail. Example: eighty thousand dollars lands on the median knot and returns percentile 50, rank 50th, and band middle. Two hundred twenty-five thousand dollars sits halfway between the two-hundred-thousand and two-hundred-fifty-thousand knots and returns percentile 87. POST a JSON body with one required field: income, the annual US household income in dollars. It must be a non-negative finite number; aliases annual_income, household_income, amount, and salary are accepted so a payroll row does not need a rename step. JSON numbers are preferred; numeric strings that parse as a finite decimal are accepted. Missing income, an empty string, NaN, Infinity, a non-numeric value, or a negative amount fails with invalid_input naming the field and is not billed, because a percentile is not defined for a negative household income on this table. On success the body echoes income, then returns percentile as the interpolated rank on a 0–100 scale, percentile_rounded as the nearest integer, rank as the English ordinal of that integer such as 50th or 91st, share_below equal to the percentile, share_above equal to 100 minus the percentile, and band as a coarse label such as bottom_20, lower_middle, middle, upper_middle, top_20, top_10, top_5, or top_1. The response also names the bracketing knots lower_income, lower_percentile, upper_income, and upper_percentile, plus method linear_interpolation and a formula string you can display next to the answer. Pair the rank with your own cost-of-living notes if you need regional context; this endpoint ranks against a national household table only. Pricing for a successful item is a flat $0.002.

Where a US income percentile calculator earns its keep

People who search US income percentile or household income percentile already know they have a dollar figure and want a rank, not a tax bill, not an hourly conversion, and not a k-th percentile of an arbitrary data set they would have to upload. A job-offer comparison uses it before accepting a relocation: one hundred twenty-five thousand dollars in a national household ranking is a different picture from the same number as a tax bracket. Failed validation does not consume balance. Classroom consumer-math courses assign distribution worksheets and need an oracle that marks a negative income as invalid_input instead of silently clipping to zero. Compensation dashboards and household-budget notebooks call the same contract at $0.002 per successful item without standing up a Census download pipeline. Keep requests small, pin the interpolated percentile in tests, and you get a reproducible US household rank for articles, offer letters, and lightweight finance webhooks without pretending the table is this year's survey microdata.

Integration use cases

Classroom distribution worksheets

Mark consumer-math items with a deterministic oracle that rejects negative income as invalid_input and returns a stable percentile.

Technical questions