Relative strength ratio calculator
Deadlift 100 kg at 80 kg body weight and your relative strength is 1.25 times bodyweight, or 125 %. Dividing what you lift by what you weigh lets lifters of different sizes compare fairly. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Lifted weight
- 100
- Body weight
- 80
- Relative strength
- 1.25
- Percent bodyweight
- 125
Relative strength is the classic size-normalized strength score: divide the weight you lift by your body weight and you get a dimensionless ratio that coaches, athletes, and strength-and-conditioning programs use when raw kilograms alone would favour heavier lifters. This relative strength ratio calculator applies that exact definition offline and deterministically—send positive lifted weight and positive body weight in the same mass unit, receive a stable ratio plus percent of bodyweight with the formula and unit labels.
What relative strength means for fair athlete comparison
Relative strength answers a simple question: how much can you lift for each unit of your own body mass? Mechanically it is lifted weight divided by body weight. If you deadlift one hundred kilograms at eighty kilograms body weight, your relative strength is one point two five times bodyweight, or one hundred twenty-five percent of bodyweight.
Absolute load still matters for sport selection and equipment, but when two athletes of different sizes compare a squat, bench, or pull-up progressions, the ratio levels the comparison so a lighter lifter who moves more mass per kilogram of body mass is not automatically ranked below a heavier teammate with a larger absolute total. This calculator does not apply Wilks, IPF GL, DOTS, or other federated scoring tables, does not estimate one-rep max from multi-rep sets, and does not convert kilograms to pounds for you.
Inputs must be finite and strictly greater than zero: a zero or negative lift cannot represent a useful strength trial for this model, and a zero or negative body weight cannot represent an athlete. Always frame outputs as educational performance ratios, not clinical diagnoses, competition handicaps, or medical clearance.
Where a relative strength calculator earns its keep
Secondary-school and college exercise-science courses often introduce relative strength when teaching how absolute load scales with body size, so a single trusted oracle that returns the ratio beside the formula string speeds grading and demo setup. Product teams building educational strength widgets need a documented lift-over-body-weight step that clients can audit by hand rather than a black-box score that mixes federation coefficients without disclosure. Coaching platforms preparing synthetic athlete datasets need deterministic relative-strength labels from known loads and body weights without network calls or model drift.
Club leaderboards and programming apps sometimes display relative strength next to absolute kilograms because athletes immediately understand progress relative to their own mass without memorizing every absolute target. If you later need Wilks or IPF points, one-rep-max estimators, watts per kilogram for cycling, or BMI-style body-composition tools, treat those as separate search intents and landings rather than overloading this relative-strength page. Always present results as educational estimates from the lifted weight divided by body weight definition; training decisions require qualified coaches, local context, and protocols this tool does not collect.
What you can do with it
Classroom relative-strength answer keys
Generate lifted-over-body-weight ratios so instructors and auto-graders share one transparent ground truth from the same two inputs.
FAQ
What units does the calculator use?
Any consistent mass unit for both fields (kg with kg, or lb with lb).
What happens if a value is missing, zero, or not a number?
Missing, non-numeric, zero, and negative values are rejected rather than producing a meaningless ratio.
Is this the same as Wilks or watts per kilogram?
No. This page is pure lift ÷ body weight. Wilks/IPF coefficients and cycling W/kg are separate tools and search intents.
What does it cost?
The browser tool is free and runs locally.
Why compare lifters by relative strength rather than total weight?
Raw kilograms favour heavier athletes. Dividing the lift by body mass means a lighter lifter who moves more per kilogram of their own weight is not automatically ranked below a bigger teammate with a larger total.
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/health/relative-strength \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"lifted_weight":100,"body_weight":80}'const res = await fetch("https://api.kit.forhosting.com/health/relative-strength", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"lifted_weight": 100,
"body_weight": 80
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/health/relative-strength",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"lifted_weight": 100,
"body_weight": 80
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/health/relative-strength", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"lifted_weight":100,"body_weight":80}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"lifted_weight":100,"body_weight":80}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/health/relative-strength", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"lifted_weight": 100,
"body_weight": 80
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "health.relative_strength",
"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
Zero, negative, missing, or non-numeric inputs fail with invalid_input instead of inventing a score.
What relative strength means for fair athlete comparison
Those cases fail with invalid_input rather than absolute-value workarounds that would hide data-entry mistakes. The computation is pure arithmetic with no network calls, no random seeds, no wall-clock timestamps, and no machine-learning drift, so identical inputs always yield identical JSON.
Input contract, response shape, and error behaviour
Mixing units—kilograms of bar load with pounds of body mass—produces a meaningless ratio, so convert upstream before calling. POST a JSON body with two required fields. The field lifted_weight is the load moved in your chosen mass unit and must be a finite number strictly greater than zero; aliases lift, load, weight_lifted, and lift_weight are accepted. The field body_weight is the athlete’s body mass in the same unit and must likewise be finite and strictly greater than zero; aliases body_mass, mass, weight, bw, and bodyweight are accepted. Missing fields, empty strings, non-numeric strings, NaN, Infinity, zero, and negative values fail with invalid_input and are not charged. On success the response returns the cleaned lifted_weight and body_weight, relative_strength as lifted_weight divided by body_weight, percent_bodyweight as that ratio times one hundred, the formula string relative_strength equals lifted_weight divided by body_weight, method relative_strength, and unit × bodyweight. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance. If a caller supplies aliases such as body_mass instead of body_weight, the same validation and arithmetic path applies without changing the output shape. Keep requests small, pin the cleaned relative_strength in tests, and you get reproducible ratios for LMS plugins, S&C dashboards, and edge workers without standing up a sports-science stack of your own.
Where a relative strength calculator earns its keep
Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance.
Integration use cases
S&C dashboard fixtures
Bulk-produce stable relative-strength labels for athlete profiles and regression tests with hard invalid_input on missing or non-positive values.
Educational strength widget demos
Show size-normalized strength from lift and body weight without mixing Wilks tables or 1RM estimators on the same landing.
Technical questions
How is relative strength calculated?
Divide lifted weight by body weight in the same unit: relative_strength = lifted_weight / body_weight. Example: 100 kg lift at 80 kg body weight = 1.25× bodyweight (125% bodyweight).