Cycling wattage calculator
Holding 30 km/h on a flat road with a 70 kg rider, a 10 kg bike and a CdA of 0.32 takes about 150 watts, most of it against the air. Add a gradient and see how quickly gravity takes over. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Speed
- 30
- Rider weight
- 70
- Bike weight
- 10
- Gradient
- 0
- Air resistance
- 0.32
- Watts
- 149.8613
- Speed ms
- 8.333333
- Total weight
- 80
- Rolling resistance
- 0.005
Cyclists, coaches, and indoor-trainer users constantly need a watt number from a speed they already know: a climb they just rode, a target they want to hold on the next group ride, or a virtual course they are about to start. This cycling wattage calculator converts road speed, rider mass, bike mass, road gradient, and aerodynamic drag area into a steady-state power in watts using the standard rolling-plus-gravity-plus-air-resistance balance.
What cycling wattage measures and how the forces add up
Steady-state cycling wattage is the power a rider must produce at the pedals to hold a constant ground speed against three opposing forces: rolling resistance from the tires, gravitational resistance from the slope, and aerodynamic drag from moving through air. This calculator adds rider mass and bike mass into a single system mass m, converts road speed from kilometres per hour into metres per second, and converts a percent gradient into an angle θ equal to the arctangent of grade divided by one hundred.
Rolling force is the coefficient of rolling resistance times m times g times cosine of θ. Gravity force is m times g times sine of θ. Wheel power is the sum of those three forces times ground speed.
Pedal power, the wattage a meter would display, divides wheel power by drivetrain efficiency so chain and bearing losses are not silently ignored. On a flat road the gravity term is zero and most of the watts at thirty kilometres per hour come from air; on a five percent climb the gravity term quickly dominates and the same speed can demand several hundred watts.
The arithmetic is closed-form: unlike predicting speed from a known power, which needs an iterative root finder because drag is cubic in speed, predicting wattage from a known speed is a handful of multiplies and two trigonometric calls.
Where a cycling wattage calculator earns its keep
Coaches building an outdoor target from an indoor number need watts at a known road speed, not a guess from perceived exertion. Riders planning a climb they have already paced by speed want to know whether that pace was two hundred watts or four hundred before they write intervals. Indoor-trainer users who race a virtual course can convert a listed kilometres-per-hour target plus the course grade and a realistic CdA into the wattage the trainer should hold, instead of chasing a speed that the game physics will not match.
Sports-science labs assign the rolling-plus-gravity-plus-aero identity as homework so students see why doubling speed more than doubles the watts, and why a kilogram on a steep climb costs more than a kilogram on the flat. Event organisers publishing a sportive profile can turn each segment speed and grade into a wattage band without issuing power meters to every rider. Failed validation does not consume balance.
Keep speed in kilometres per hour, masses in kilograms, gradient in percent, and CdA in square metres for the same instant — do not mix a peak sprint speed with an average climb grade from another ride — and you get a reproducible watt figure for dashboards, LMS quizzes, and edge workers without standing up a strain-gauge laboratory of your own. Treat speed-from-power, pace-from-distance, calorie burn, and generic vehicle drag as separate product intents rather than overloading this wattage page with every related sports formula.
What you can do with it
Climb pacing without a power meter
Turn a known road speed, rider and bike mass, percent grade, and CdA into the pedal watts that climb would have cost, then write the next interval from that number.
Indoor trainer course targets
Convert a virtual-course speed and listed gradient into a wattage the trainer should hold, using the same rolling, gravity, and aero split as an outdoor ride.
Classroom power-balance homework
Let students check the closed-form identity P = (F_roll + F_grav + F_aero)·v / η against hand calculation, with a hard error on any negative input.
FAQ
How is cycling wattage calculated from speed?
The calculator adds rider and bike mass, converts speed from km/h to m/s, and sums rolling, gravity, and aero forces. Pedal watts equal that force sum times speed, divided by drivetrain efficiency (default 0.975).
What happens if any input is negative?
Negative speed, mass, gradient, air resistance, rolling resistance, density, or efficiency is rejected and is not billed.
Is this the same as a power meter reading?
It is the mechanical power implied by the standard steady-state force balance at constant speed, not a strain-gauge measurement. Use a realistic CdA and Crr; gusts, acceleration, and drafting are not modelled.
What CdA value should I enter?
CdA is your drag area: drag coefficient times frontal area, in square metres. A rider on the hoods typically sits around 0.30 to 0.35. A lower value means a more aerodynamic position and fewer watts at the same speed.
Can I work out watts for a downhill?
No. A negative gradient is refused instead of returning a negative wattage that would look like freewheeling. Zero is a flat road, and climbs up to 50 percent are accepted.
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/sports/cycling-wattage \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"speed":30,"rider_weight":70,"bike_weight":10,"gradient":0,"air_resistance":0.32}'const res = await fetch("https://api.kit.forhosting.com/sports/cycling-wattage", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"speed": 30,
"rider_weight": 70,
"bike_weight": 10,
"gradient": 0,
"air_resistance": 0.32
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/sports/cycling-wattage",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"speed": 30,
"rider_weight": 70,
"bike_weight": 10,
"gradient": 0,
"air_resistance": 0.32
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/sports/cycling-wattage", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"speed":30,"rider_weight":70,"bike_weight":10,"gradient":0,"air_resistance":0.32}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"speed":30,"rider_weight":70,"bike_weight":10,"gradient":0,"air_resistance":0.32}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/sports/cycling-wattage", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"speed": 30,
"rider_weight": 70,
"bike_weight": 10,
"gradient": 0,
"air_resistance": 0.32
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "sports.cycling_wattage",
"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_speed_kmh | 150 |
max_rider_weight_kg | 400 |
max_bike_weight_kg | 80 |
max_gradient_pct | 50 |
max_air_resistance | 2 |
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
You do not need a power meter on the bike: the same physics that a meter infers from strain, this tool infers from speed and the forces that oppose it. Negative speed, mass, gradient, or drag is rejected as invalid_input instead of a silent negative wattage that would look like a downhill freewheel.
What cycling wattage measures and how the forces add up
Air-resistance force is one half times the drag area CdA times air density times speed squared; the air_resistance you supply is that combined CdA used in every cycling power model. Identical inputs always produce identical JSON because the module is pure, with no clock, no random seed, and no network.
Input contract, response shape, and error behaviour
Any negative numeric input is rejected: a negative speed, mass, gradient, drag area, rolling coefficient, density, or efficiency cannot build a physical wattage, and those failures are not billed. Zero speed is allowed and returns zero watts. Zero gradient is a flat road. Wire the free browser form for a personal estimate, then call the identical contract from scripts when you need bulk climb tables. POST a JSON body with five required finite numbers: speed in kilometres per hour, rider_weight in kilograms, bike_weight in kilograms, gradient as a percent slope, and air_resistance as CdA in square metres. Each field may arrive as a JSON number or as a numeric string. Aliases speed_kmh, kmh, v, and velocity are accepted for speed; rider, rider_kg, and rider_mass for the rider; bike, bike_kg, and bike_mass for the bicycle; grade, grade_pct, slope, and incline for the climb; cda, CdA, drag_area, and aero for the drag area. Optional rolling_resistance defaults to 0.005, air_density defaults to 1.225 kilograms per cubic metre, efficiency defaults to 0.975, and precision defaults to four decimal places. Missing fields, empty strings, NaN, Infinity, and non-numeric text fail with invalid_input naming the field. On success the body includes watts as the primary pedal power, the cleaned speed and speed_ms, both masses and their total, gradient, air_resistance, rolling_resistance, air_density, efficiency, the three force components in newtons, the three power splits plus power_wheel_w, method steady_state_power_balance, precision, and a formula string documenting P = [Crr·m·g·cosθ + m·g·sinθ + ½·CdA·ρ·v²]·v / η. Successful API calls use prepaid KIT balance at the published $0.002 base price per item; validation failures do not consume balance.
Technical questions
What units does the cycling wattage calculator use?
Speed is kilometres per hour, rider_weight and bike_weight are kilograms, gradient is percent, and air_resistance is CdA in square metres. Optional air_density is kg/m³.
What does the cycling wattage calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.