Temperature gradient converter
0.03 K/m is 0.0164592 °F/ft. Convert a temperature gradient between kelvin, Celsius, Fahrenheit and Rankine per meter, foot, inch, centimeter, millimeter or kilometer, for borehole logs, insulation work or thin lab samples. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 0.03
- From
- k/m
- To
- f/ft
- Result
- 0.0164592 °F/ft
- Input
- 0.03
- K per m
- 0.03
Need a reliable temperature gradient converter for geothermal surveys, building heat-loss work, or laboratory thermal design? Enter a numeric gradient, choose the source unit and the target unit, and get an exact conversion among kelvin per meter, Fahrenheit per foot, Celsius per centimeter and related engineering units.
Which temperature-gradient units you can convert
This temperature gradient converter focuses on the units that appear most often in geothermal science, building physics, process engineering and materials testing. Kelvin per meter (K/m) is the SI hub: one kelvin of temperature change per meter of depth or path length. Because a kelvin interval equals a Celsius degree interval, Celsius per meter is numerically identical to kelvin per meter and is accepted as a first-class unit for reports that prefer degree Celsius symbols.
Kelvin and Celsius per centimeter or per millimeter match laboratory and thin-sample work where gradients are steep over short distances. Per-kilometer forms serve continental heat-flow tables and deep-basin models. On the imperial side, Fahrenheit per foot is common in North American building codes, soil temperature surveys and older oilfield thermal logs; Fahrenheit per inch and per meter cover instrument intervals and mixed metric-imperial drawings.
Rankine per foot and per meter follow the same interval scale as Fahrenheit and appear in some US thermodynamic worksheets. Millikelvin per meter supports high-precision cryogenic and metrology notes. Identical-unit requests simply echo the value after validation, which is useful when you only need a known unit check in a data pipeline.
How conversion and exact factors work
Every conversion multiplies the input into kelvin per meter, then divides by the target unit factor. That single-hub pattern avoids stacking rounding errors when you jump from Fahrenheit per foot to Celsius per centimeter or from kelvin per meter to Fahrenheit per inch.
Length factors are exact international definitions: one foot is exactly zero point three zero four eight meters, one inch is exactly zero point zero two five four meters, one centimeter is exactly one hundredth of a meter, one millimeter is one thousandth, and one kilometer is one thousand meters. Temperature scales use interval conversion only—not absolute zero offsets—because a gradient is a difference per length. One kelvin interval equals one Celsius degree interval exactly.
One Fahrenheit or Rankine degree interval equals five ninths of a kelvin interval. Combining those yields, for example, the exact Fahrenheit-per-foot to kelvin-per-meter factor of five ninths divided by zero point three zero four eight.
What you can do with it
Geothermal and borehole temperature logs
Normalize mixed K/m and °F/ft gradients from offset wells or heat-flow surveys into one unit before plotting or comparing to regional models.
Building insulation and HVAC design checks
Convert °C/cm or K/m wall and slab gradients to the unit your code checklist or client specification requires.
FAQ
Is °C/m the same as K/m?
Yes for gradients. A one-degree Celsius interval equals a one-kelvin interval, so numerical values of °C/m and K/m are identical. Absolute temperature conversion is not involved.
How do I convert K/m to °F/ft?
Multiply by 0.3048 to go from per meter to per foot, and by 9/5 because a Fahrenheit degree is five ninths of a kelvin. That is how 0.03 K/m becomes 0.0164592 °F/ft.
Why is no Fahrenheit or kelvin offset added?
A gradient is a temperature difference per length, so only the size of the degree matters. The converter uses interval factors and never the zero-point offsets used for absolute temperatures.
Which gradient units suit geothermal work?
Per-kilometer forms suit continental heat-flow tables and deep-basin models, while °F/ft is common in North American soil temperature surveys and older oilfield thermal logs.
What is millikelvin per meter used for?
It serves high-precision cryogenic and metrology notes, where gradients are tiny. One kelvin per meter equals 1000 mK/m, so the number simply grows by a factor of a thousand.
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/conv/thermal-gradient \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":0.03,"from":"k/m","to":"f/ft"}'const res = await fetch("https://api.kit.forhosting.com/conv/thermal-gradient", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 0.03,
"from": "k/m",
"to": "f/ft"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/thermal-gradient",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 0.03,
"from": "k/m",
"to": "f/ft"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/thermal-gradient", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":0.03,"from":"k/m","to":"f/ft"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":0.03,"from":"k/m","to":"f/ft"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/thermal-gradient", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"value": 0.03,
"from": "k/m",
"to": "f/ft"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.thermal_gradient",
"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
Run it free in the browser or call the identical logic through the API at $0.002 per request with no subscription and no model inference.
Which temperature-gradient units you can convert
Short aliases and underscore forms such as f_per_ft, celsius_per_centimeter or kelvin/m are accepted and normalized to a canonical slash form in the response.
How conversion and exact factors work
There is no network call, no model inference and no clock dependency: the same input always produces the same JSON. Unknown units raise invalid_input naming the field and listing supported units, so bad client data is never charged as a successful conversion.
Using the API, pricing and delivery
Call the capability with three fields: value as a finite number, from as the source unit string, and to as the target unit string. Status is beta while the surface stabilizes, but the arithmetic itself follows fixed SI definitions and will not change under the same inputs. The response includes the numeric input, the canonical from and to unit keys, the converted result, a human-readable unit label such as °F/ft or K/m, and the intermediate k_per_m value so auditors can recompute the step by hand or chain further conversions offline. Pricing for the hosted API is a flat $0.002 per successful request; failed validation such as a missing field or an unknown unit does not consume balance. For pipelines, submit each conversion as an independent task and collect results through your usual webhook or signed link flow. Keep source and destination units explicit in your integration rather than parsing free-text symbols: that contract keeps SDK types, OpenAPI schemas and form controls aligned, and it prevents silent misreads when a feed mixes metric and imperial labels.
Integration use cases
Engineering homework and unit tests
Assert exact conversions between imperial and SI temperature gradients in graded exercises and continuous-integration fixtures.
Technical questions
Which temperature gradient units are supported?
K/m, °C/m, K/cm, °C/cm, K/mm, °C/mm, K/km, °C/km, K/ft, °C/ft, K/in, °C/in, °F/m, °F/cm, °F/mm, °F/km, °F/ft, °F/in, °R/m, °R/ft, °R/in and mK/m, plus common aliases. Unknown units return invalid_input.
How much does the temperature gradient converter API cost?
Each successful API call costs $0.002. The same converter runs free in your browser with no account required.
Is the conversion deterministic?
Yes. The math uses fixed SI length factors and exact temperature-interval scales through K/m with ten-decimal rounding, so the same input always yields the same JSON result.
What happens if I send an unknown unit?
The request fails with invalid_input explaining that the unit is unknown and listing supported values. Invalid client input is not charged.