Nautical mile converter
One nautical mile is exactly 1852 metres, 1.852 kilometres and 1.150779448024 statute miles. Enter any distance in nautical miles from a chart, a flight briefing or a sailing plan and get all three land units together, from exact international factors. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Nautical miles
- 1
- Kilometers
- 1.852
- Statute miles
- 1.150779448
- Meters
- 1,852
- Factor kilometers
- 1.852
A nautical mile is the marine and aviation distance unit defined so that one international nautical mile equals exactly one thousand eight hundred fifty-two metres. Pilots, mariners, chart readers, coastal weather desks, and travel planners still quote ranges in nautical miles, while most land maps, car odometers, school worksheets, and logistics sheets speak in kilometres, statute road miles, or metres. This nautical mile converter accepts a non-negative distance in nautical miles and returns the same length in kilometres, statute miles, and metres using only those fixed international factors—never a survey-mile shortcut and never a rounded 1.15 rule of thumb.
What a nautical mile is and which exact factors this converter uses
The international nautical mile is a defined length, not an average of degrees of latitude and not a rounded classroom shortcut. Metrology and hydrographic practice fix one nautical mile at exactly one thousand eight hundred fifty-two metres, which is exactly one point eight five two kilometres. That is the constant used on modern charts, in the definition of the knot as one nautical mile per hour, and in this converter.
Statute miles—the ordinary road miles used on United States highway signs and many imperial odometers—are a different unit. One international statute mile is exactly one thousand six hundred nine point three four four metres, from five thousand two hundred eighty feet of zero point three zero four eight metres each.
Bridging through the metre therefore gives a unique, reproducible triple: kilometres equal nautical miles times one point eight five two; metres equal nautical miles times one thousand eight hundred fifty-two; statute miles equal nautical miles times one thousand eight hundred fifty-two divided by one thousand six hundred nine point three four four. One nautical mile is therefore one point eight five two kilometres, one thousand eight hundred fifty-two metres, and a little more than one point one five zero seven eight statute miles.
Ten nautical miles scale those identities by ten. Approximate rules such as “about one point one five” or “about one point eight five” are rejected so homework checks, exam keys, and logbook exports match engineering tables instead of drifting on long passages. This landing is a dedicated nautical-mile converter: the input is always nautical miles, and the three land units are always returned together.
Where a nautical mile converter earns its keep, and what it costs
Marine and aviation briefings still publish visibility, diversion range, and coastal legs in nautical miles, while the people who have to act on those numbers often think in kilometres or road miles. A skipper comparing a twelve-nautical-mile harbour approach with a metric chart, a student converting textbook problems that mix sea miles and statute miles, and a logistics script importing logbook rows into a kilometre-based warehouse all need the same three numbers without opening a general multi-unit hub and picking from and to by hand.
Classroom oracles and exam generators need a deterministic contract that rejects negative input instead of silently returning a signed length that a buggy grader might treat as success. Failed validation does not consume balance. Keep requests small, pin the rounded kilometres, statute miles, and metres in tests, and you get reproducible conversions for briefing cards, LMS plugins, and edge workers without standing up a full unit-conversion library of your own.
What you can do with it
Marine and aviation briefings
Rewrite a charted range or diversion in nautical miles into kilometres, statute miles, and metres so a briefing card matches the land units on a metric chart or road atlas.
Classroom and exam checks
Let students submit a non-negative nautical-mile distance and verify the exact kilometre, statute-mile, and metre answers against the 1852 m definition.
FAQ
How many kilometres are in one nautical mile?
Exactly 1.852 kilometres. One international nautical mile is defined as 1852 metres, so kilometres equal nautical miles times 1.852.
How does a nautical mile differ from a statute mile?
A nautical mile is 1852 metres. A statute (road) mile is 1609.344 metres.
Why is the nautical mile fixed at 1852 metres?
The international nautical mile was defined as exactly 1852 metres so charts, the knot, and hydrographic tables share one constant instead of a latitude-dependent minute of arc.
Is a knot the same as a nautical mile?
No. A knot is a speed, one nautical mile per hour, while the nautical mile is a distance. This converter handles distances only, so it turns nautical miles into kilometres, statute miles and metres but does not convert knots.
Why not just multiply nautical miles by 1.15?
Because a rounded rule of thumb drifts on long passages and will not match exam keys or logbooks. The converter goes through the metre: one nautical mile is 1852 metres and one statute mile is 1609.344, giving 1.150779448024 statute miles.
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/life/nautical-mile \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"nautical_miles":10}'const res = await fetch("https://api.kit.forhosting.com/life/nautical-mile", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"nautical_miles": 10
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/life/nautical-mile",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"nautical_miles": 10
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/life/nautical-mile", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"nautical_miles":10}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"nautical_miles":10}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/life/nautical-mile", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"nautical_miles": 10
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "life.nautical_mile",
"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 | 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
Missing, non-numeric, or negative input fails with invalid_input and is not billed.
Input contract, response fields, and how invalid distances fail
Zero converts to zero in every output unit. Send a JSON body with one required field named nautical_miles. The value must be a non-negative finite number, either a JSON number or a plain numeric string, including optional scientific notation when you need a very large charted range. Aliases nmi, nm, distance, amount, value, and nautical_mile are accepted so spreadsheets, typed forms, and SDK clients can reuse the name that already exists in the source system. Negative distances fail with invalid_input because a length cannot be less than zero in this contract; the message names nautical_miles so the web control can be marked invalid. Missing fields, empty strings, bare plus or minus signs, spelled-out words without a number, NaN, and Infinity also fail with invalid_input and are never billed. Magnitudes above one quadrillion nautical miles are rejected so the Worker isolate stays inside a published limit. Pair the numbers with your own map or plot if you need a picture; this endpoint converts length only and does not emit tracks or bearings.
Where a nautical mile converter earns its keep, and what it costs
This page does not convert knots, does not turn statute miles back into nautical miles as a primary form, and does not accept mixed unit strings such as “ten nmi plus two km”; send a single non-negative nautical-mile figure and read the three land units from the JSON.
Integration use cases
Logbook and app imports
Convert a column of nautical-mile legs into SI and statute fields for a warehouse, fitness export, or CI fixture without a general multi-unit converter.
Technical questions
What happens if I enter a negative distance?
The task fails with invalid_input. A length cannot be negative in this contract, so the request is rejected and is not billed.
What does the nautical mile converter cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.