Pressure altitude converter
In the standard atmosphere, 850 hPa sits at 1457.299451504714 m. Convert pressure to altitude and back, or switch between hPa, inHg, mmHg, psi, meters and feet, for altimeter settings, flight charts, weather balloons and homework. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Numeric quantity to convert
- 850
- Source unit
- hPa
- Target unit
- m
- Result
- 1,457.2994515047
- From label
- hectopascal
- To label
- meters altitude
- Pascals
- 85,000
A pressure altitude converter turns barometric static pressure written in one unit into geometric altitude—or the reverse—under the International Standard Atmosphere, and also converts freely among pressure units and among altitude units without hunting tables or rewriting spreadsheet formulas. Pressure-to-pressure and altitude-to-altitude paths use exact conventional SI factors; pressure-to-altitude paths use the closed-form ICAO ISA troposphere power law with published sea-level constants, so identical inputs always produce identical outputs with no network calls, no model sampling, and no clock dependence.
Supported units and how the conversion is computed
The converter accepts eleven canonical codes in two families. Pressure units are hPa for the hectopascal, mbar for the millibar (identical to hPa under this product contract), Pa for the SI pascal, kPa for the kilopascal, inHg for inches of mercury at the conventional 3386.389 pascals per inch factor, mmHg for millimeters of mercury (torr) at 133.322387415 pascals, atm for the standard atmosphere of 101325 pascals, and psi for pounds per square inch at the standard lbf-per-square-inch factor.
Altitude units are m for meters of geometric altitude, ft for feet using the exact international foot of 0.3048 meters, and km for kilometers. When both units are pressure, the engine multiplies the input by the pascals-per-unit factor for the source and divides by the factor for the target. When both units are altitude, the same pattern uses meters as the intermediate.
When one unit is pressure and the other is altitude, the engine maps through the ICAO International Standard Atmosphere troposphere model: altitude from pressure is h equals (T0 over L) times (1 minus (P over P0) raised to (R times L over g0)), and pressure from altitude is P equals P0 times (1 minus L times h over T0) raised to (g0 over R times L), with P0 equal to 101325 pascals, T0 equal to 288.15 kelvin, L equal to 0.0065 kelvin per meter, g0 equal to 9.80665 meters per second squared, and R equal to 287.05287 joules per kilogram-kelvin for dry air.
Where it helps pilots, forecasters and students
Use the free in-browser pressure altitude converter when you need a quick hectopascal-to-meters, inches-of-mercury-to-feet, or meters-to-hPa check while reading a METAR altimeter setting, an aircraft performance chart, a barometric logger export, a weather balloon profile, or a homework problem on the standard atmosphere. Open the page, enter the number and units, and copy the result without installing a spreadsheet, a unit library, or a desktop aviation calculator pack.
Source inputs follow the same retention rules as other KIT parse items, and results are safe to cache because the algorithm is fully deterministic.
What you can do with it
Aviation and flight planning
Convert altimeter settings and static pressure in hPa or inHg to pressure altitude in feet or meters for performance charts, briefing tools, and checklist apps under the ICAO standard atmosphere.
Weather and barometric loggers
Normalize station pressure readings among hPa, mbar, inHg, and mmHg, and estimate geometric altitude for field sensors that report only static pressure.
FAQ
Which units are supported?
Pressure: hPa, mbar, Pa, kPa, inHg, mmHg, atm, psi. Altitude: m, ft, km.
What happens if I send an unknown unit?
The message names the bad field and lists the supported units; validation failures are not charged.
Is the pressure altitude converter free?
The browser tool runs free on your device.
What altitude matches a pressure of 850 hPa?
1457.299451504714 meters in the International Standard Atmosphere. The converter starts from sea-level values of 101325 Pa and 288.15 K and applies the standard troposphere formula, so the same pressure always gives the same altitude.
Up to what altitude does the conversion work?
From -500 meters to 11 000 meters, the band where the troposphere formula holds. Requests outside that range are refused instead of quietly inventing a stratosphere layer.
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/pressure-altitude \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":1013.25,"from":"hPa","to":"m"}'const res = await fetch("https://api.kit.forhosting.com/conv/pressure-altitude", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 1013.25,
"from": "hPa",
"to": "m"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/pressure-altitude",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 1013.25,
"from": "hPa",
"to": "m"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/pressure-altitude", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":1013.25,"from":"hPa","to":"m"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":1013.25,"from":"hPa","to":"m"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/pressure-altitude", 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": 1013.25,
"from": "hPa",
"to": "m"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.pressure_altitude",
"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
The browser tool runs free on your device; the prepaid API charges $0.002 per successful item when pipelines need the same contract from servers and automation.
Supported units and how the conversion is computed
Friendly aliases such as hectopascal, inches of mercury, millimeters of mercury, feet altitude, meters altitude, millibar, atmosphere, and torr are normalized case-insensitively so forms and APIs can pass either short codes or full names. The geometric altitude domain for the ISA path is minus 500 meters through 11 000 meters so the troposphere closed form stays valid; values outside that band fail with invalid_input rather than silently inventing a stratosphere layer.
Request shape, response fields, and unknown-unit errors
ISA paths also surface model ICAO_ISA_troposphere and the constants P0_Pa, T0_K, and lapse_K_per_m so clients can document the convention without re-deriving it. The error message names the bad field and lists the supported set so clients can correct forms without guessing. Zero and positive pressures convert cleanly within the model; non-positive pressure values on a pressure-to-altitude path are rejected because the ISA power law requires P greater than zero. Send a JSON body with three required fields: value as a finite number, from as the source unit string, and to as the target unit string. Aliases amount, quantity, pressure, and altitude are accepted for value; unit_from and source for from; unit_to and target for to. When pressure is involved the response includes the intermediate pascals quantity; when altitude is involved it includes altitude_m in meters. Missing value, non-finite numbers such as NaN or Infinity, missing unit fields, and any token that does not map to a supported unit fail with invalid_input and are not charged after the engine rejects the request. Identical inputs always yield identical JSON because the path is pure arithmetic with no randomness, no remote lookup, and no dependence on the wall clock, which makes the endpoint safe to pin in continuous-integration goldens and SDK contract tests.
Browser use, API pricing, and everyday workflows
Switch to the prepaid API when a flight-planning tool, weather pipeline, drone telemetry normalizer, lab data logger, or atmospheric-science homework checker must convert pressure altitude at scale under a stable KIT contract at $0.002 per successful item; validation failures that raise invalid_input do not consume balance after rejection. Pair this endpoint with pure pressure-head or force-area converters when a product pipeline needs several measure families, or call it alone when search traffic is specifically for pressure-to-altitude conversion—hPa, inHg, meters, and feet under the standard atmosphere—rather than a general unit switchboard or a water-column head converter. Authors shipping mobile apps or chatbots can map the result, altitude_m, pascals, and formula fields directly into cards that show both the number and the ISA conversion path students, pilots, and meteorologists expect on paper.
Integration use cases
Lab and classroom pipelines
Convert Pa, kPa, atm, psi, and altitude units for atmospheric-science problems and data loggers with a prepaid, deterministic API and clear invalid_input on unknown units.
Technical questions
How do I convert hectopascals to meters of altitude?
Send JSON with value set to the pressure (for example 1013.25), from: "hPa", and to: "m". The response includes result, intermediate pascals, altitude_m, and a readable ISA formula line.
Which atmosphere model does the converter use?
Pressure ↔ altitude uses the ICAO / ISO 2533 International Standard Atmosphere troposphere formulas with P0 = 101325 Pa, T0 = 288.15 K, and L = 0.0065 K/m, valid from −500 m to 11 000 m geometric altitude.