Revised Trauma Score calculator
Glasgow 15, systolic pressure 120 mmHg and 16 breaths per minute give the maximum Revised Trauma Score of 7.8408. Enter the three bedside observations and get each code from 0 to 4 plus the weighted total. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Gcs
- 15
- Sbp
- 120
- Respiratory rate
- 16
- Gcs code
- 4
- Sbp code
- 4
- Rr code
- 4
- Revised trauma score
- 7.8408
The Revised Trauma Score, often abbreviated RTS, is the physiology score Champion, Sacco, Copes, Gann, and colleagues published in 1989 to summarise three bedside observations into one weighted number for trauma teaching and research coding. This calculator accepts the Glasgow Coma Scale, systolic blood pressure in millimetres of mercury, and respiratory rate in breaths per minute, maps each observation onto the published 0–4 coded table, and returns the weighted RTS using the Champion coefficients 0.9368 for GCS, 0.7326 for systolic pressure, and 0.2908 for respiratory rate.
What the Revised Trauma Score measures and how Champion coding works
The Revised Trauma Score is a bedside physiology score, not an anatomic injury scale. Champion and colleagues derived it so that three immediately available observations—level of consciousness, systolic blood pressure, and respiratory rate—could be collapsed into a single number that still weighted consciousness more heavily than breathing. Each observation is first recoded onto an integer from zero through four using the published Champion intervals, then multiplied by a fixed coefficient, then summed.
Glasgow Coma Scale values of 13 to 15 code as 4, 9 to 12 as 3, 6 to 8 as 2, 4 to 5 as 1, and 3 as 0; values below 3, which are not in the original table, are coded 0 so the calculator can accept any non-negative number without inventing a fifth band. Systolic blood pressure greater than 89 mmHg codes as 4, 76 to 89 as 3, 50 to 75 as 2, 1 to 49 as 1, and 0 as 0.
Respiratory rate of 10 to 29 breaths per minute codes as 4, rates above 29 as 3, 6 to 9 as 2, 1 to 5 as 1, and 0 as 0. The weighted score is RTS equals 0.9368 times the GCS code plus 0.7326 times the systolic code plus 0.2908 times the respiratory-rate code. The theoretical maximum is 7.8408 when every code is 4; the minimum is 0 when every code is 0.
How to read the weighted score, where the calculator belongs, and what it does not decide
A weighted RTS near 7.84 is the physiology band of an uninjured or minimally injured teaching vignette: eyes open, oriented, a normal blood pressure, and a normal respiratory rate. Scores in the mid range, for example a GCS of 8, systolic pressure of 80 mmHg, and respiratory rate of 8, produce codes 2, 3, and 2 and a weighted RTS of 4.6530, which many teaching discussions treat as a cue to talk about airway, circulation, and transfer rather than as a discharge number.
A score of 0 is the arithmetic floor: GCS 3 or below, no measurable systolic pressure, and no respiratory effort. Those numbers are historical physiology scores from a 1989 derivation, not a personal prognosis, and they do not replace anatomic injury scoring, imaging, serial examination, or a clinician's view of comorbidities this table never captures. Use the calculator for education, exam keys, research coding of trauma rows, and product prototypes that need a deterministic RTS step before handing off to licensed systems.
Neighbouring tools such as a shock-index or mean-arterial-pressure calculator answer different search intents and should keep their own landings rather than being overloaded here.
What you can do with it
Teaching vignettes and exam keys
Score textbook trauma cases so instructors and auto-graders share one Champion 1989 ground truth for the three codes and the weighted RTS.
Research coding of trauma cohorts
Attach a reproducible Revised Trauma Score to study rows when GCS, systolic pressure, and respiratory rate are already in the table.
Prototype decision-support scaffolds
Wire a transparent RTS step into educational apps and checklists that later hand off to licensed clinical systems for real decisions.
FAQ
What is the Revised Trauma Score (RTS)?
It is Champion's 1989 physiology score from Glasgow Coma Scale, systolic blood pressure, and respiratory rate. This tool returns the 0–4 coded values and the weighted RTS using coefficients 0.9368, 0.7326, and 0.2908.
How is the weighted RTS calculated?
The result is rounded to four decimal places and ranges from 0 to 7.8408.
What happens if an input is negative or missing?
Every input must be a non-negative finite number; missing fields, NaN, Infinity, and negative values are rejected and are not billed.
Is a respiratory rate of 0 or a systolic pressure of 0 allowed?
Yes. Zero is a published Champion code-0 row (no measurable pressure or no respiratory effort). Only negative or non-numeric values are rejected.
Can I use this result to triage a real patient?
No. This is an educational arithmetic aid, not medical advice. Real triage, transfer, and treatment need a licensed clinician and the rest of the clinical picture this calculator does not collect.
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/revised-trauma-score \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"gcs":15,"sbp":120,"respiratory_rate":16}'const res = await fetch("https://api.kit.forhosting.com/health/revised-trauma-score", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"gcs": 15,
"sbp": 120,
"respiratory_rate": 16
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/health/revised-trauma-score",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"gcs": 15,
"sbp": 120,
"respiratory_rate": 16
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/health/revised-trauma-score", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"gcs":15,"sbp":120,"respiratory_rate":16}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"gcs":15,"sbp":120,"respiratory_rate":16}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/health/revised-trauma-score", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"gcs": 15,
"sbp": 120,
"respiratory_rate": 16
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "health.revised_trauma_score",
"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
Every input must be a non-negative finite number; a missing field, a negative value, or a non-numeric token fails with invalid_input and is not billed. Treat the JSON as a transparent arithmetic aid, not a diagnosis or a substitute for licensed trauma, emergency, or critical-care judgment.
What the Revised Trauma Score measures and how Champion coding works
This capability implements that published table and those three coefficients exactly, with no hidden adjustments, so a hand-scored vignette and the JSON body can be compared line by line in class, in a notebook, or in an automated test suite.
Input contract, validation, and the shape of a successful response
Each must be a non-negative finite number: zero is legal, because a systolic pressure of 0 mmHg and a respiratory rate of 0 breaths per minute are the published code-0 rows, not a form error. Optional output keys are omitted rather than set to null. A classic check case is Glasgow Coma Scale 15, systolic pressure 120 mmHg, and respiratory rate 16 breaths per minute: every code is 4 and the weighted RTS is 7.8408. Send a JSON object with three required fields. The canonical names are gcs, sbp, and respiratory_rate. JSON numbers and numeric strings are accepted; aliases such as glasgow_coma_scale, glasgow, gcs_score, systolic_blood_pressure, systolic, sbp_mmhg, rr, resp_rate, and respiratory are mapped onto the canonical names, but the response always echoes the canonical keys. A missing field, an empty string, null, an array, an object, Infinity, NaN, or a negative value fails with invalid_input naming the field and stating that a non-negative number was expected; those failures are not billed. On success the body returns the echoed vitals, the three integer codes gcs_code, sbp_code, and rr_code in the 0–4 Champion bands, revised_trauma_score as the weighted total rounded to four decimal places, and a formula string restating the 1989 identity. Pair the free browser form with the same contract from scripts; successful API calls cost $0.002 per item and validation failures do not consume prepaid balance.
How to read the weighted score, where the calculator belongs, and what it does not decide
Do not triage a real incident, withhold imaging, or issue a transfer decision from this JSON alone. The arithmetic is pure parse with no outbound network, so identical inputs always yield identical JSON, and the published API price remains $0.002 per successful request.
Technical questions
What does the Revised Trauma Score calculator cost?
The browser widget runs free and locally. The same computation via the API is billed at $0.002 per successful request; invalid_input failures are not charged.