Wheel horsepower calculator
With 300 horsepower at the crank and a 15% drivetrain loss, 255 reach the driven wheels and 45 are lost. Enter the engine figure and the loss you want to apply to compare a brochure with a chassis dyno sheet. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Crank power
- 300
- Loss percent
- 15
- Efficiency percent
- 85
- Wheel power
- 255
- Power lost
- 45
This wheel horsepower calculator converts crank engine power into the power that actually reaches the driven wheels after drivetrain losses. Chassis dynamometers report wheel horsepower; manufacturer brochures and engine dynos report crank or flywheel figures. The gap is the percentage of power absorbed by the transmission, torque converter, driveshaft, differential, transfer case, and related rotating parts. Enter crank power and a drivetrain loss percent from zero to one hundred; the engine returns delivered wheel power as crank power times one minus that percent over one hundred. Zero loss leaves the crank figure unchanged. One hundred percent loss delivers nothing at the pavement.
What wheel horsepower is and how the loss percent is applied
Wheel horsepower is the power delivered at the driven wheels after the drivetrain has taken its share. Crank or flywheel horsepower is measured at the engine output, before the clutch or torque converter. Everything between those two stations—gears, bearings, viscous couplings, a transfer case on all-wheel-drive cars, even a long driveshaft on a truck—dissipates energy as heat and noise.
If a brochure quotes three hundred horsepower at the flywheel and you assume a fifteen percent drivetrain loss, the pavement sees two hundred fifty-five horsepower and forty-five horsepower is lost. The same identity works in kilowatts, metric PS, or watts because it is a scale factor, not a unit conversion. Zero percent models an ideal rigid drivetrain and returns the crank figure unchanged.
One hundred percent models a complete absorption and returns zero at the wheels. Typical street manuals sit near ten to fifteen percent, automatics a little higher, and all-wheel-drive layouts often eighteen to twenty-five, but those ranges are context for the reader, not defaults hidden in the engine. You supply the percent that matches the car, the test method, or the shop rule of thumb you want to apply.
Where a wheel horsepower figure is used in shops, forums, and software
Tuners and independent shops use a wheel horsepower calculator when a customer brings a crank rating from a brochure and wants a realistic number to compare with a chassis dyno sheet. Forum threads that argue whether a claimed four hundred horsepower car should put three hundred forty or three hundred twenty to the ground can pin the disagreement on the loss percent instead of mixing units.
Fleet and performance writers convert manufacturer flywheel figures into wheel figures so two vehicles with different drivetrain layouts can be compared on the same station. Educators teaching power, efficiency, and energy conservation use the identity as a one-step example that still maps onto a real car. Developers call the same contract from scripts to seed deterministic test vectors for automotive calculators, to normalize user-entered crank and loss fields before a comparison table, or to satisfy a product brief that demands a delivered-power field rather than a guessed correction.
Pair it with a horsepower-to-kilowatt converter when you need a unit change, or with a wheel-torque calculator when you need axle torque from gear ratios, and keep this page for the single search intent: crank power to wheel horsepower from a drivetrain loss percent.
What you can do with it
Brochure crank rating versus chassis dyno
Turn a manufacturer flywheel horsepower figure and a shop loss percent into the wheel number you expect on a chassis dynamometer.
Forum and classifieds reality check
Convert a claimed crank rating into delivered wheel power so two listings with different drivetrains can be compared on the same station.
FAQ
What happens if the loss percentage is outside 0 to 100?
A drivetrain loss cannot be a negative percent or more than the whole crank output, so those requests are not billed.
Which power unit should I use?
Any consistent unit works: mechanical horsepower, kilowatts, metric PS, or watts. The calculator applies a scale factor and does not convert between units.
Does the calculator pick a loss percent from the drivetrain type?
No. You supply the percent. Typical street manuals sit near 10–15 percent and all-wheel-drive often higher, but those ranges are guidance, not a hidden table.
What is the difference between crank and wheel horsepower?
Crank horsepower is measured at the engine output, before the clutch or torque converter, and is the figure in brochures. Wheel horsepower is what is left after the gearbox, differential and other parts, and is what a chassis dyno reads.
What drivetrain loss percentage is typical?
As a guide, street cars with a manual gearbox sit near ten to fifteen percent, automatics a little higher and all-wheel-drive layouts often eighteen to twenty-five percent. The calculator never applies these on its own: you choose the value.
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/life/wheel-horsepower \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"crank_power":300,"loss_percent":15}'const res = await fetch("https://api.kit.forhosting.com/life/wheel-horsepower", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"crank_power": 300,
"loss_percent": 15
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/life/wheel-horsepower",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"crank_power": 300,
"loss_percent": 15
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/life/wheel-horsepower", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"crank_power":300,"loss_percent":15}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"crank_power":300,"loss_percent":15}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/life/wheel-horsepower", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"crank_power": 300,
"loss_percent": 15
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "life.wheel_horsepower",
"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.
Limits
max_crank_power | 1000000000000 |
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
A loss outside that closed interval is rejected as invalid_input instead of inventing a negative or inverted result.
What wheel horsepower is and how the loss percent is applied
The simple and widely used model treats that dissipation as a single percentage of crank power: wheel power equals crank power times one minus loss percent over one hundred.
Input contract, response shape, and what invalid_input rejects
Missing fields, empty strings, non-numeric tokens, NaN, and Infinity fail the same way and are not billed. There is no gear-ratio table, no chassis-dyno correction factor, and no clock: three hundred at fifteen percent always yields two hundred fifty-five. POST a JSON body with two required finite numbers: crank_power for engine output at the crankshaft or flywheel, and loss_percent for the drivetrain loss as a percentage of that output. Both may arrive as JSON numbers or as numeric strings. Aliases are accepted in the same roles so a spreadsheet or a typed form can post without renaming columns: engine_power, flywheel_power, crank_hp, horsepower, or power for crank_power; and loss, drivetrain_loss, drivetrain_loss_percent, or percent_loss for loss_percent. crank_power must be non-negative and no larger than one trillion; a negative crank rating is not a physical engine output, and zero crank power is allowed and yields zero wheel power. loss_percent must lie in the closed interval from zero to one hundred inclusive. A value below zero or above one hundred fails with invalid_input that names the field, because a percent of engine power cannot be negative or greater than the whole. On success the body echoes cleaned crank_power and loss_percent, reports efficiency_percent as one hundred minus the loss, returns wheel_power as the delivered figure, reports power_lost as the absorbed remainder, and includes formula as the printable identity.
Where a wheel horsepower figure is used in shops, forums, and software
On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns.
Integration use cases
Scripts and automotive calculators
Normalize crank_power and loss_percent in a deterministic pipeline before a comparison table or a teaching demo that must never invent a negative wheel figure.
Technical questions
How do I convert crank horsepower to wheel horsepower?
Send crank_power and a drivetrain loss_percent from 0 to 100. The API returns wheel_power = crank_power × (1 − loss_percent / 100) in the same unit you entered.
What does the wheel horsepower calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.