ForHosting KIT · Health & fitness

Fat-free mass index calculator

Scores your lean mass against your stature: at 80 kg, 1.8 m and 15% body fat, 68 kg of lean mass is divided by height squared to give FFMI in kg/m². That lets you compare athletes of different statures. 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

Weight: 80
Height: 1.8
Body-fat percentage: 15

You get

Weight (kg): 80 kg/m²
Height m: 1.8
Body fat percent: 15
Fat free mass kg: 68

Fat-free mass index puts lean body mass on a height-scaled footing so two athletes at different statures can be compared without treating scale weight as the whole story. This capability takes body weight in kilograms, standing height in meters, and body-fat percentage, computes fat-free mass as weight times one minus the fat fraction, then divides by height squared to produce FFMI in kilograms per square meter. It also returns a height-normalized FFMI using the familiar one-point-eight meter reference adjustment so short and tall athletes map onto a comparable band. Body fat above one hundred percent is rejected as invalid input because fat-free mass cannot be negative.

What FFMI measures and how it is worked out

Body mass index divides total weight by height squared, so fat and muscle end up mixed in one number. FFMI uses the same geometry with lean tissue only. First the fat mass is removed from your weight using a measured body-fat percentage; then the remaining lean mass is divided by your height in meters squared. At 80 kg and 15% body fat, 12 kg is fat and 68 kg is lean mass, and those 68 kg are divided by 1.8 m squared. Alongside the raw value you get a normalized FFMI adjusted to a 1.8 m reference, so short and tall athletes land on a comparable band.

Where it helps and what to watch for

FFMI is common in strength sports, physique coaching and research that needs a lean-mass score adjusted for stature. Coaches use it to follow lean mass on a height-scaled band while an athlete cuts or bulks, something scale weight alone cannot show. Weight goes in kilograms, and height in meters or centimeters, as long as you pick the matching unit. A body-fat figure above 100% is rejected because lean mass cannot be negative, and heights outside a sensible adult range are refused as well, so a typing slip does not turn into a believable score.

What you can do with it

Strength and physique coaching

Coaches enter scale weight, height, and a measured body-fat percentage to track lean mass on a height-scaled FFMI band as athletes cut or bulk.

FAQ

What is the fat-free mass index formula?

Fat-free mass is weight in kg times (1 − body fat percent / 100). FFMI is fat-free mass divided by height in meters squared (kg/m²). This calculator applies that formula exactly and also returns a height-normalized FFMI.

What happens if body fat is above 100 percent?

Body-fat percentage cannot exceed 100 percent; values above that limit are rejected and not charged.

Which units should I use for weight and height?

If your UI collects pounds or inches, convert before calling so the published FFMI definition applies correctly.

Is the fat-free mass index calculator free?

The browser tool runs free on your device.

How is normalized FFMI different from raw FFMI?

Raw FFMI is fat-free mass over height squared. Normalized FFMI adjusts toward a 1.8 m reference height with the common 6.1 × (1.8 − height) term so shorter and taller athletes can be compared on one band.

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/health/fat-free-mass-index

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/health/fat-free-mass-index \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"weight":80,"height":1.8,"body_fat":15}'

const res = await fetch("https://api.kit.forhosting.com/health/fat-free-mass-index", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "weight": 80,
    "height": 1.8,
    "body_fat": 15
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/health/fat-free-mass-index",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "weight": 80,
    "height": 1.8,
    "body_fat": 15
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/health/fat-free-mass-index", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"weight":80,"height":1.8,"body_fat":15}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"weight":80,"height":1.8,"body_fat":15}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/health/fat-free-mass-index", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "weight": 80,
  "height": 1.8,
  "body_fat": 15
}

Example response

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

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

The path is pure arithmetic with no network and no random seed, so coaching apps, sports-science notebooks, and prepaid API clients get identical JSON every time.

What fat-free mass index measures and which inputs you need

Body mass index divides total weight by height squared and therefore mixes fat and lean tissue into one number. Fat-free mass index does the same geometry with lean tissue only: first subtract fat mass from weight using a measured body-fat percentage, then divide the remaining fat-free mass by height in meters squared. The result, reported as ffmi with unit kilograms per square meter, is widely used in strength sports, physique coaching, and research that wants a stature-adjusted lean-mass score. Missing fields, non-finite numbers, non-positive weight or height, and heights outside a safe adult range also fail validation. Send weight as a positive finite number in kilograms; aliases weight_kg, body_weight, and mass_kg are accepted. Send height as a positive finite number in meters; aliases height_m and stature_m are accepted, and height_cm is accepted when you prefer centimeters—the engine divides by one hundred. Send body_fat as a percentage from zero through one hundred inclusive; aliases body_fat_percent, bf, fat_percent, and bodyfat are accepted. The engine multiplies weight by one minus body fat over one hundred to obtain fat_free_mass_kg, reports fat_mass_kg as the complement, and computes ffmi as fat-free mass over height squared. If body fat exceeds one hundred percent the request fails with invalid_input and is not charged. Identical inputs always yield identical JSON because the algorithm never touches the network, a model, a clock, or a random generator.

Reading the response fields and common pitfalls

The unit field is always kg/m² so UIs can label the index without hard-coding strings. Remember that body-fat percentage must come from a measurement you already trust—DEXA, hydrostatic weighing, a quality BIA device, or a skinfold protocol—because this calculator does not estimate composition from circumference, photos, or clothing size. Extremely large weights or heights outside the published isolate safety window are also rejected. On success the response echoes weight_kg, height_m, and body_fat_percent, then fat_free_mass_kg, fat_mass_kg, ffmi, and normalized_ffmi. The formula field restates FFMI equals fat-free mass over height squared, and method is always fat_free_mass_index so downstream code can branch without sniffing shapes. Normalized FFMI applies the common six-point-one times one-point-eight minus height adjustment so athletes shorter or taller than the reference stature can be compared on a single band; use ffmi when you want the raw scientific index and normalized_ffmi when your coaching literature quotes the height-adjusted figure. Percentages above one hundred are impossible and raise a clear invalid_input message mentioning that body fat exceeds one hundred percent. Do not confuse this endpoint with BMI, BMR, or total daily energy expenditure: those answer different questions and live on other capabilities or product layers after you receive FFMI.

API usage, pricing, coaching workflows, and practical limits

Call the free in-browser fat-free mass index calculator for quick checks, lecture demos, and client education without installing a sports-science spreadsheet. Keep expectations clinical: this is an educational and planning estimate, not a diagnostic medical device, and users with atypical body composition or medical conditions should follow professional advice rather than any single index alone. Send a JSON body with required weight, height, and body_fat (or their aliases). Use the prepaid API when a fitness SaaS, team performance platform, telehealth intake form, or research notebook needs a stable contract under KIT balance at $0.002 per successful item; validation failures never consume balance after the engine rejects the request. Pair this endpoint with a body-fat measurement workflow on the client side, then store fat-free mass and FFMI in your own database for longitudinal charts across a season. Prefer kilogram weight and meter height that match the published formula; if your UI collects pounds or centimeters, convert or use height_cm before calling. Authors shipping SDKs can map ffmi and normalized_ffmi directly into dashboards and export CSV columns labeled lean mass and fat-free mass index—the same numbers coaches write by hand when they apply FFMI on paper.

Integration use cases

Fitness and sports-science apps

Apps that already store composition readings call a stable prepaid endpoint for FFMI instead of reimplementing fat-free mass over height squared in every client language.

Classroom and lab demos

Courses compare BMI against fat-free mass index and pin expected JSON in automated tests with deterministic outputs.

Read the full KIT documentation →

Run — free