Gibbs free energy calculator
For ΔH of −92.4 kJ/mol, ΔS of −0.1987 kJ/(mol·K) and 298.15 K, ΔG comes out at −33.157595 kJ/mol, which is spontaneous. Type the three values, pick your decimals and compare the TΔS term of −59.242405 with your own work. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Enthalpy
- -92.4
- Entropy
- -0.1987
- Creativity
- 298.15
- Gibbs
- -33.157595
- T delta s
- -59.242405
- Spontaneity
- spontaneous
- Precision
- 10
This Gibbs free energy calculator evaluates the thermodynamic relation ΔG equals ΔH minus T times ΔS for a chemical reaction or physical process at constant temperature. You supply the enthalpy change ΔH, the entropy change ΔS, and the absolute temperature T in kelvin; the engine returns the free-energy change ΔG, the intermediate TΔS term, and a spontaneity label so you can see at a glance whether the process is spontaneous, non-spontaneous, or at equilibrium under those conditions. The arithmetic is fully deterministic: one multiplication and one subtraction on finite numbers, with no network calls, no table lookups, and no date-dependent shortcuts. Keep energy units consistent before you call—if ΔH is in kilojoules per mole and ΔS is in kilojoules per mole-kelvin, ΔG comes back in kilojoules per mole.
Where ΔG fits in study, lab work, and software
Students meet Gibbs free energy when a general-chemistry unit links enthalpy tables to spontaneity, when a physical-chemistry course derives ΔG from the combined first and second laws, or when an exam problem asks whether a reaction is spontaneous at a stated temperature without computing equilibrium constants. Teachers can pre-generate answer keys for modest ΔH and ΔS values without trusting opaque calculator apps that silently switch from joules to kilojoules and flip the sign of TΔS.
Developers call the same contract from scripts to seed deterministic test vectors for thermo dashboards, to normalize user-entered reaction parameters before process demos, or to satisfy programming-challenge statements that demand ΔG rather than a hand-waved yes or no. Lab and process work often needs a fast, offline source of free-energy checks so report numbers can be verified against the stated formula under time pressure.
Product and education tools use the evaluation when a learner types enthalpy, entropy, and temperature and the UI must show ΔG and a clear spontaneous or non-spontaneous label.
What you can do with it
Homework and exam spontaneity checks
Plug textbook ΔH, ΔS, and T into ΔG = ΔH − TΔS and verify whether the reaction is spontaneous at the stated temperature.
Lab reports and tutoring software
Normalize user-entered enthalpy, entropy, and kelvin temperature into ΔG for worksheets, plotters, and interactive thermo lessons.
FAQ
What does the Gibbs free energy calculator cost?
It is free in your browser on this page.
How is ΔG defined?
ΔG = ΔH − T·ΔS, where ΔH is the enthalpy change, ΔS the entropy change, and T the absolute temperature in kelvin. Keep energy units consistent across ΔH and ΔS.
What happens if temperature is negative?
Negative absolute temperature is non-physical for this relation on the kelvin scale.
Does this tool look up standard enthalpies of formation?
No. You must supply ΔH and ΔS yourself. The calculator only evaluates the algebraic Gibbs relation and classifies spontaneity from the sign of ΔG.
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/chem/gibbs-from-enthalpy-entropy \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"enthalpy":-92.4,"entropy":-0.1987,"temperature":298.15}'const res = await fetch("https://api.kit.forhosting.com/chem/gibbs-from-enthalpy-entropy", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"enthalpy": -92.4,
"entropy": -0.1987,
"temperature": 298.15
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/chem/gibbs-from-enthalpy-entropy",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"enthalpy": -92.4,
"entropy": -0.1987,
"temperature": 298.15
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/chem/gibbs-from-enthalpy-entropy", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"enthalpy":-92.4,"entropy":-0.1987,"temperature":298.15}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"enthalpy":-92.4,"entropy":-0.1987,"temperature":298.15}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/chem/gibbs-from-enthalpy-entropy", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"enthalpy": -92.4,
"entropy": -0.1987,
"temperature": 298.15
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "chem.gibbs_from_enthalpy_entropy",
"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_value | 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
What Gibbs free energy means and what the response contains
Gibbs free energy is the state function that tells you whether a process can proceed spontaneously at constant temperature and pressure. The fundamental combination ΔG equals ΔH minus T times ΔS folds the heat of reaction and the entropy-driven term into a single energy-like quantity with a clear sign rule: negative ΔG favors the forward process, positive ΔG favors the reverse as written, and zero marks equilibrium. This calculator implements that closed form only. It returns the normalized enthalpy, entropy, and temperature you supplied, the product T times ΔS as t_delta_s so you can audit the intermediate, the free-energy change gibbs rounded to the requested precision, a boolean spontaneous flag that is true when ΔG is negative, false when positive, and null when the result is at equilibrium within a tiny numeric epsilon, a string spontaneity tag of spontaneous, non_spontaneous, or equilibrium, the precision used, the method tag gibbs_from_enthalpy_entropy, the formula string ΔG equals ΔH minus T times ΔS, and a short unit_note reminding you to keep energy scales consistent. There is no approximate CAS path and no random sampling of conditions: the engine either builds a finite ΔG inside the supported magnitude range or rejects the input with invalid_input. Rejected cases include missing enthalpy, entropy, or temperature, non-finite values, magnitudes above the documented ceiling, and any temperature that is strictly negative on the absolute kelvin scale.
How enthalpy, entropy, and temperature are read and stay reproducible
Optional leading plus signs and scientific notation on numeric strings are allowed when they parse as finite decimals; embedded spaces, hex prefixes, and non-numeric tokens are rejected with a clear message so a bad cell does not become a wrong free-energy value. Zero entropy or zero enthalpy is valid and simply yields a pure temperature or pure enthalpy contribution. The preferred fields are enthalpy for ΔH, entropy for ΔS, and temperature for absolute T in kelvin, but aliases such as delta_h, dH, and enthalpy_change for enthalpy, delta_s, dS, and entropy_change for entropy, and T, temp, kelvin, and temp_k for temperature are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. Temperature must be non-negative: if T is less than zero, the request fails with invalid_input because negative absolute temperature is non-physical for this relation and would silently invert the sign of the TΔS term in a misleading way. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for all numeric fields, 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 free-energy formula yourself.
Where ΔG fits in study, lab work, 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. 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 molar-enthalpy or equilibrium tools when you need related thermo steps, and with other chemistry endpoints when you are building a small lab of free, deterministic reaction helpers.
Integration use cases
Deterministic test fixtures
Generate reproducible gibbs, t_delta_s, and spontaneity labels for unit tests, property checks, and CI assertions.