Carnot efficiency calculator
An engine working between 600 K and 300 K can reach at most 50 % efficiency. Enter the hot and cold reservoir temperatures in kelvin to get the Carnot limit as a fraction and as a percent. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- T hot
- 600
- T cold
- 300
- Efficiency
- 0.5 fraction
- Efficiency percent
- 50
- Precision
- 10
This Carnot efficiency calculator finds the maximum theoretical efficiency of a heat engine operating between a hot reservoir and a cold reservoir when you know both absolute temperatures in kelvin. The defining closed form is eta equals one minus the cold temperature divided by the hot temperature, which is the classic second-law limit taught in introductory thermodynamics, engineering heat engines, and physics homework. Temperatures must already be on an absolute scale: convert Celsius or Fahrenheit yourself before calling the tool, because the ratio Tc over Th is only meaningful in kelvin (or another absolute unit used consistently). Both temperatures must also be positive absolute values. The engine is fully deterministic arithmetic: no network calls, no sampling, and no date-dependent shortcuts.
What Carnot efficiency means and what you get
A reversible heat engine that exchanges heat only with two thermal reservoirs reaches its highest possible efficiency when it operates on a Carnot cycle. That upper bound depends only on the two absolute temperatures: eta equals one minus Tc over Th. The result is a pure number between zero and one, often reported as a percent for classroom work.
It is not the efficiency of any particular real engine; friction, finite-rate heat transfer, and other irreversibilities always push a practical plant below the Carnot ceiling. Absolute temperature is essential: zero kelvin is absolute zero, so both reservoirs must be positive and Th must exceed Tc.
Where the Carnot limit fits in study, design, and software
Students meet eta equals one minus Tc over Th when a textbook introduces the second law, when a problem gives boiler and condenser temperatures and asks for the maximum possible efficiency, or when a contest problem insists on kelvin before taking the ratio. Teachers can pre-generate answer keys for modest reservoir pairs without trusting opaque calculator apps that silently treat Celsius as absolute or reverse hot and cold.
Developers call the same contract from scripts to seed deterministic test vectors for thermal simulators, to normalize user-entered reservoir temperatures before a process sketch, or to satisfy programming-challenge statements that demand a fraction rather than a hand-waved percent. First-order engineering checks use the Carnot bound when only two temperatures are known, before irreversibility factors, heat losses, or multi-stage cycles are modeled.
What you can do with it
Homework and lab checks
Compute η = 1 − Tc/Th from kelvin reservoir temperatures before grading heat-engine worksheets or thermo labs.
Design bounds and tutoring software
Normalize user-entered hot and cold temperatures into a maximum efficiency for process sketches and interactive lessons.
FAQ
What does the Carnot efficiency calculator cost?
It is free in your browser on this page.
How is Carnot efficiency defined?
For a heat engine between two reservoirs, η = 1 − T_c / T_h, where both temperatures are absolute (kelvin). The result is returned as a fraction and as a percent.
What happens if the hot temperature is not greater than the cold?
Carnot efficiency η = 1 − Tc/Th requires T_hot > T_cold on an absolute temperature scale.
Can I enter temperatures in Celsius?
No automatic conversion is applied. Convert to kelvin first (T_K = t_C + 273.15), then supply T_hot and T_cold as absolute temperatures.
Why are results rounded to a precision?
Default precision is 10 decimal places; you can set precision from 0 to 15.
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/heat-engine-efficiency \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"T_hot":600,"T_cold":300}'const res = await fetch("https://api.kit.forhosting.com/thermo/heat-engine-efficiency", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"T_hot": 600,
"T_cold": 300
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/thermo/heat-engine-efficiency",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"T_hot": 600,
"T_cold": 300
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/thermo/heat-engine-efficiency", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"T_hot":600,"T_cold":300}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"T_hot":600,"T_cold":300}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/thermo/heat-engine-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
{
"T_hot": 600,
"T_cold": 300
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "thermo.heat_engine_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.
Limits
max_abs_temperature | 1000000000000000 |
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
Hot temperature must be strictly greater than cold temperature; equal or inverted reservoirs are rejected with invalid_input because a heat engine cannot produce work between reservoirs that do not establish a positive temperature gradient.
What Carnot efficiency means and what the response contains
This calculator returns the normalized inputs T_hot and T_cold, the efficiency as a fraction, the efficiency as a percent, the precision used, a method tag carnot_efficiency, a short formula reminder, and a unit hint that the primary efficiency is a fraction. There is no automatic unit conversion from Celsius, no steam-table lookup, and no Monte Carlo sampling of cycles: the engine either evaluates the closed form inside the supported numeric range or rejects the input with invalid_input. Rejected cases include a missing hot or cold temperature, non-finite values, magnitudes above the documented ceilings, non-positive absolute temperatures, and any case where hot temperature is not strictly greater than cold temperature, because Carnot efficiency is undefined for a non-driving temperature pair in this model.
How reservoir temperatures are read and how efficiency stays reproducible
Both must be finite positive numbers on an absolute scale (kelvin). Optional leading plus signs and scientific notation on numeric strings are allowed when they parse as finite decimals; embedded spaces and non-numeric tokens are rejected. The preferred field for the hot reservoir is T_hot, but aliases Th, T_h, hot, hot_temperature, and hot_temp are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. The preferred field for the cold reservoir is T_cold, with aliases Tc, T_c, cold, cold_temperature, and cold_temp. A non-positive temperature fails with invalid_input and a message that names the field and requires a positive absolute temperature in kelvin, so a Celsius-looking zero does not become a silent nonsense ratio. When hot temperature is not greater than cold temperature, the request fails with invalid_input and an explicit message that Carnot efficiency requires T_hot greater than T_cold. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for the numeric outputs, defaulting to ten and capped at fifteen so JSON goldens stay stable. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing the efficiency formula yourself.
Where the Carnot limit fits in study, design, and software
Product and education tools use the endpoint when a learner types hot and cold kelvin values and the UI must show the ideal efficiency ceiling. 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. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result. Pair it with other thermo helpers when you need related energy steps, and with math endpoints when you are building a small lab of free, deterministic physics calculators.
Integration use cases
Deterministic test fixtures
Generate reproducible Carnot efficiencies for unit tests, thermal demos, and CI assertions on the ideal limit.