Thermal efficiency calculator
An engine that delivers 300 J of work from 1000 J of heat runs at 30 % efficiency and rejects 700 J. Enter the work output and the heat input in the same energy unit to get the percentage, the fraction and the rejected heat. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Work output
- 300
- Heat input
- 1,000
- Thermal efficiency
- 30 %
- Efficiency fraction
- 0.3
- Heat rejected
- 700
Thermal efficiency is the fraction of heat absorbed from a hot source that a heat engine converts into net useful work, usually reported as a percentage. In the standard first-law definition you measure two energy quantities for a cycle or a steady operating interval: the work output W delivered by the engine and the heat input Q_in taken from the hot reservoir. Their ratio defines η equals W divided by Q_in, or one hundred times that ratio when you want the familiar percent form used in textbooks, lab reports, and plant dashboards. This calculator accepts those two numbers, validates that heat input is not zero, then returns the efficiency as a percentage, the dimensionless fraction, and the complementary heat rejected to the cold sink under the simple closed-cycle balance Q_out equals Q_in minus W. Zero heat input is rejected with a clear validation error because the defining formula would divide by zero and no physical engine can report an efficiency without absorbing heat.
How thermal efficiency is defined from work and heat
Start from the classical heat-engine idealization used in secondary school and first-year engineering thermodynamics: a device that absorbs heat Q_in from a high-temperature source, rejects some heat Q_out to a cold sink, and delivers net work W over a cycle. Energy conservation for a cyclic process requires that the net work equal the difference between heat absorbed and heat rejected, so W equals Q_in minus Q_out when both heats are measured as positive magnitudes into and out of the engine.
Thermal efficiency is then defined as the useful work per unit of heat purchased from the hot source: η equals W over Q_in. Multiplying by one hundred converts that fraction into a percentage, which is how most homework answers, nameplate ratings, and plant performance reports present the number. The calculator implements exactly that algebraic definition.
It does not impose the Carnot upper bound from absolute temperatures, does not integrate irreversibilities along a path, and does not specialize the formula for Otto, Diesel, Brayton, or Rankine cycles that replace W and Q_in with temperature or compression-ratio expressions. Those cycle formulas are different search intents and deserve their own landings. Work may be zero, which yields zero efficiency and is a valid degenerate case.
Work larger than heat input yields an efficiency above one hundred percent, which is allowed mathematically and can flag measurement error or a model outside the simple heat-engine balance.
Where thermal efficiency calculations show up in real work
Secondary-school and college physics courses constantly assign heat-engine problems that give work output and heat input and ask for thermal efficiency as a percent, often before they introduce Carnot limits or cycle-specific formulas. University engineering labs reduce measured shaft work and calorimeter heat release to a single η number before they discuss second-law availability or component efficiencies. Power-plant and combined-heat-and-power engineers sanity-check nameplate claims by backing out η from logged megawatt-hours of electricity and fuel heat input over the same interval.
Automotive and aerospace test cells compare indicated or brake work against fuel energy to report indicated and brake thermal efficiency without running a full cycle simulation. If you later need Carnot efficiency from two absolute temperatures, Otto or Diesel cycle efficiency from compression ratio and gamma, or unit conversion between joules and BTU before the ratio step, treat those as separate search intents and landings rather than overloading this thermal efficiency calculator page.
What you can do with it
Homework and exam answer keys
Compute η as a percentage from textbook work output and heat input pairs so teachers and auto-graders share one ground truth.
Lab and plant performance checks
Reduce measured shaft work and fuel or steam heat input to thermal efficiency and first-law heat rejected for lab reports and dashboards.
Design notebooks and what-if energy balances
Explore how changing work delivery or heat supply shifts percentage efficiency before committing to a detailed cycle model.
FAQ
Does this enforce the Carnot limit?
No. Carnot efficiency from hot and cold absolute temperatures is a different formula and a different search intent. This tool only evaluates η from W and Q_in.
What does it cost?
The browser tool is free and runs locally.
How much heat does the engine reject?
The heat rejected is the heat input minus the work output, under the simple energy balance of a cycle. With 1000 J in and 300 J of work, 700 J go to the cold side.
Can the efficiency come out above 100 %?
Yes, if the work you enter is larger than the heat input. The calculator shows it rather than hiding it, but a real engine cannot do that, so it usually points to a measurement error.
What happens if the heat input is zero?
The calculation is refused with a clear message, because the efficiency would require dividing by zero and no engine can produce work without absorbing heat. Check your energy balance and enter the heat actually absorbed.
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/thermo/thermal-efficiency \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"work_output":300,"heat_input":1000}'const res = await fetch("https://api.kit.forhosting.com/thermo/thermal-efficiency", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"work_output": 300,
"heat_input": 1000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/thermo/thermal-efficiency",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"work_output": 300,
"heat_input": 1000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/thermo/thermal-efficiency", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"work_output":300,"heat_input":1000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"work_output":300,"heat_input":1000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/thermo/thermal-efficiency", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"work_output": 300,
"heat_input": 1000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "thermo.thermal_efficiency",
"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
How thermal efficiency is defined from work and heat
Division by zero is the critical edge: if heat_input is exactly zero or vanishes within floating-point epsilon, the ratio is undefined, so the request fails with invalid input instead of returning Infinity or NaN.
What you send and what you get back
Classic textbook checks include three hundred joules of work from one thousand joules of heat for thirty percent efficiency; a laboratory engine delivering two hundred kilojoules of work from eight hundred kilojoules of fuel heat for twenty-five percent; and a zero-work case that correctly reports zero percent. Keep work and heat in matching units so the ratio is dimensionless before the percent scale is applied. Send two finite numbers under the fields work_output and heat_input. work_output is the net work W in joules or any energy unit you prefer, and may be positive for engines or zero for a failed conversion. heat_input is Q_in in the same energy unit and must be non-zero; both fields are required. Missing fields, non-numeric strings, NaN, and Infinity fail with invalid_input and are not charged. When heat_input is zero the error message states that thermal efficiency cannot be computed because division by zero would occur in η equals W over Q_in, so clients can fix the energy balance rather than guessing. On success the response echoes cleaned inputs, thermal_efficiency as the percentage value, efficiency_fraction as the dimensionless ratio W over Q_in, heat_rejected as Q_in minus W under the first-law closed-cycle idealization, a unit string of percent, the formula string, and method thermal_efficiency. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance.
Where thermal efficiency calculations show up in real work
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.
Technical questions
What formula does this thermal efficiency calculator use?
η = (W / Q_in) × 100, where W is work_output and Q_in is heat_input in matching energy units. The response also includes the fraction W/Q_in and heat_rejected = Q_in − W.
What happens if heat input is zero?
The request fails with invalid_input. Thermal efficiency is undefined when Q_in = 0 because the defining ratio would divide by zero.
Can efficiency exceed 100%?
Mathematically yes if work_output is larger than heat_input. That usually signals inconsistent units or a model outside a simple heat-engine balance; the calculator does not clamp the result.