ForHosting KIT · Science

Internal energy change calculator

Apply the first law in one step: 500 J of heat absorbed while the system does 200 J of expansion work leaves an internal energy change of 300 J, with a note on what the sign means. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Heat: 500
Work: 200

You get

Q: 500
Q: 500
Heat added: 500
W: 200

An internal energy change calculator applies the first law of thermodynamics to two energy transfers you already know: the heat added to a closed system and the work that system does on its surroundings. Enter Q and W in any consistent energy unit—joules, kilojoules, or calories—and the tool returns ΔU equals Q minus W, mirrored field names for delta U, a formula string, a short interpretation of the sign of ΔU, and step-by-step substitution you can paste into lab notebooks, homework, or automated tests.

What the first law says about ΔU, heat, and work

For a closed thermodynamic system the first law states that the change in internal energy equals the heat added to the system minus the work done by the system when the common chemistry convention for work is used. In symbols that is delta U equals Q minus W. Internal energy U is a state function: only the initial and final states matter for ΔU, while Q and W depend on the path.

Heat is positive when energy enters the system as heat and negative when heat leaves. Work is positive when the system expands or otherwise does work on the surroundings and negative when the surroundings do net work on the system, for example in compression. Subtracting W from Q therefore accounts for energy that leaves as work.

Teachers and automated graders care about consistent sign conventions as much as arithmetic: a student who treats W as work done on the system must flip the sign of W before using this tool, because the published formula is always ΔU equals Q minus W_by. Typical classroom numbers include absorbing five hundred joules of heat while doing two hundred joules of expansion work, which yields ΔU equals three hundred joules, or releasing heat while being compressed, which can produce a positive or negative ΔU depending on magnitudes.

The check path recomputes Q minus W with the same fixed rounding used for published fields, so a successful response always ships with steps you can assert in tests, worksheets, or thermochemistry lab reports about the first law of thermodynamics.

What you can do with it

Homework checks for first-law ΔU = Q − W

Students enter heat added and work done by the system from textbook problems and compare hand-written ΔU and sign interpretation against a deterministic result before submitting.

Lab notebook energy balance for closed systems

Convert measured or estimated Q and expansion work into internal energy change for general chemistry or intro physics lab write-ups.

FAQ

What formula does this internal energy change calculator use?

The first law with the chemistry convention ΔU = Q − W, where Q is heat added to the system and W is work done by the system.

What if my textbook defines W as work done on the system?

That convention uses ΔU = Q + W_on. Either negate your work value before calling this tool, or use ΔU = Q + W with W_on offline.

What units should I use for Q and W?

Any consistent energy unit (J, kJ, cal, …). The tool does not convert units; ΔU is returned in the same unit as your inputs.

Is the internal energy change calculator free?

The browser tool is free and runs locally.

What does a negative ΔU mean?

It means the internal energy of the system decreased: more energy left as work or heat than came in. A positive ΔU means net energy entered, and zero means the two transfers balance out.

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

POSThttps://api.kit.forhosting.com/chem/internal-energy-change

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/chem/internal-energy-change \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"heat":500,"work":200}'

const res = await fetch("https://api.kit.forhosting.com/chem/internal-energy-change", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "heat": 500,
    "work": 200
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/chem/internal-energy-change",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "heat": 500,
    "work": 200
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/chem/internal-energy-change", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"heat":500,"work":200}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"heat":500,"work":200}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/chem/internal-energy-change", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "heat": 500,
  "work": 200
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "chem.internal_energy_change",
  "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

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

max_abs 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

Non-numeric inputs are rejected with a clear invalid_input error so a missing value, a unit label, or a typo never becomes NaN in a report.

How to call the API and what comes back

Both fields must be finite numbers; blank strings, pure text labels, objects, and non-numeric tokens are rejected. Send a JSON body with two required finite numbers: heat (aliases q, Q, heat_added, heat_transfer, and heat_in) and work (aliases w, W, work_done, work_by_system, and work_out). Absolute values must stay within the published limit of one trillion so the difference remains finite in IEEE double precision on the Worker and in the browser. On success the response echoes rounded heat and work, mirrors them as q, Q, heat_added, w, W, work_done, and work_by_system, sets internal_energy_change, delta_u, delta_U, dU, and Delta_U to the same rounded result, formula to the string ΔU equals Q minus W, equation to a filled substitution string, interpretation to a short English note on whether internal energy increased, decreased, or stayed the same, message to a summary line, and steps to an ordered array of calculation lines. Failed validation—missing fields, non-finite numbers, non-numeric strings, values outside absolute limits, or a non-finite difference—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item and zero marginal unit price.

Practical tips, limits, and related thermochemistry searches

Keep energy units consistent with your report: if Q and W are both in kilojoules, ΔU is in kilojoules; mixing joules with kilojoules without converting will silently mis-scale the answer because this tool does not convert units. Prefer sending numbers rather than pre-formatted strings when you control the client; string numbers are accepted only when they match a strict finite numeric pattern. Prefer this capability when you already have Q and W under the work-by-the-system convention and only need ΔU; if your textbook defines W as work on the system, negate W first or rearrange offline. When teaching chemistry or physics, pair examples: Q equals five hundred and W equals two hundred recovers ΔU equals three hundred with a positive interpretation; Q equals negative one hundred and W equals fifty recovers ΔU equals negative one hundred fifty; equal heat and work yields ΔU equals zero; and deliberately send a non-numeric heat or work string to demonstrate the hard invalid_input path that guards against garbage-in garbage-out. This landing targets people searching for an internal energy change calculator, first law of thermodynamics ΔU equals Q minus W, heat and work chemistry homework help, or delta U online; it is not a full cycle efficiency tool, not an ideal-gas process integrator that starts from P-V paths, and not a calorimeter temperature solver that builds Q from mass and specific heat. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately send bad tokens. Round-trip checks are easy: recompute Q minus W by hand and confirm it equals the published internal_energy_change within the same twelve-decimal rounding, and confirm that ΔU plus W recovers the original heat within that rounding for lab report verification.

Integration use cases

Unit tests for student thermodynamics solvers

Generate known-good positive, negative, and zero ΔU cases plus deliberate non-numeric rejections for coding kata expected values in chemistry tools.

Technical questions

What happens with non-numeric input?

Missing fields, blank strings, pure text, or other non-finite values return invalid_input and are never charged.

Read the full KIT documentation →

Run — free