ForHosting KIT · Travel & geography

Speed unit converter

100 km/h comes out as 62.137119223733 mph, with the same speed also shown in knots and metres per second. Use it for cross-border drives or marine and aviation briefings without mixing statute and nautical miles. 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

Value: 100
Source unit: km/h
Target unit: mph

You get

Result: 62.1371192237
From label: kilometers per hour
To label: miles per hour
Meters per second: 27.7777777778

Travel speeds appear in different units depending on country, vehicle class, and domain: road signs use kilometers per hour or miles per hour, aviation and marine charts use knots, and physics or sensor logs often store meters per second. Converting among those four units by hand is easy to get wrong when someone mixes statute miles with nautical miles or forgets that a knot is not the same as a kilometer per hour. This speed unit converter applies fixed international factors through a meters-per-second intermediate, returns a precise numeric result plus the same speed expressed in every supported unit, and rejects unrecognized unit names with a clear invalid input error so pipelines never silently treat “kphh” or free text as a real unit.

Supported units, exact factors, and how conversion works

Send a finite numeric value together with a source unit and a target unit. The engine recognizes kilometers per hour under forms such as km/h, kph, kmh, and kilometers per hour; miles per hour as mph, mi/h, or miles per hour; knots as kn, kt, kts, knot, knots, or nautical miles per hour; and meters per second as m/s, mps, or meters per second.

Internally every quantity is multiplied by a fixed factor that yields meters per second: one kilometer per hour is exactly one thousand meters over three thousand six hundred seconds, one international mile per hour uses one thousand six hundred nine point three four four meters per mile, and one knot uses the international nautical mile of one thousand eight hundred fifty two meters. Dividing that intermediate by the target factor produces the converted speed.

Negative values are allowed when you model signed velocity deltas; non-finite numbers such as NaN or Infinity fail validation. The response also lists all four units under the all map so a single call can fill a comparison table without a second request.

What you can do with it

Cross-border road trip planning

Convert posted km/h limits to mph (or the reverse) when driving between metric and imperial countries so navigation copy and alerts match local signs.

Marine and aviation briefings

Translate knots from charts and ATC into km/h or m/s for ground teams, passenger apps, and mixed-unit training materials without mixing statute and nautical miles.

FAQ

Which speed units can I convert?

Kilometers per hour (km/h), miles per hour (mph), knots (kn/kt), and meters per second (m/s).

What happens if the unit is unrecognized?

The error message names the bad token and lists supported units. Validation failures are not charged.

Is the speed unit converter free?

The browser tool runs free on your device.

Are knots the same as km/h?

No. One knot is one international nautical mile per hour (1852 m/h), which is about 1.852 km/h—not the same as one kilometer per hour or one statute mile per hour.

What conversion factors are used?

Every speed passes through metres per second: one km/h is 1000 metres in 3600 seconds, one mph uses 1609.344 metres per mile, and one knot uses the international nautical mile of 1852 metres. The factors are fixed, so the same input always gives the same result.

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/travel/speed-unit-convert

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/travel/speed-unit-convert \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"value":100,"from":"km/h","to":"mph"}'

const res = await fetch("https://api.kit.forhosting.com/travel/speed-unit-convert", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "value": 100,
    "from": "km/h",
    "to": "mph"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/travel/speed-unit-convert",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "value": 100,
    "from": "km/h",
    "to": "mph"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/travel/speed-unit-convert", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"value":100,"from":"km/h","to":"mph"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"value":100,"from":"km/h","to":"mph"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/travel/speed-unit-convert", 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": 100,
  "from": "km/h",
  "to": "mph"
}

Example response

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

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

Reading the result fields and handling invalid units

Prefer result when you only need the target unit; use all when a dashboard must show km/h, mph, knots, and m/s side by side; use formula when teaching or logging the exact path taken. Typos such as “kphh”, “mp/h”, or “knotts” are rejected rather than guessed, which keeps telemetry and booking integrations honest. On success the response echoes the original value, the canonical from and to unit ids, human-readable from_label and to_label strings, the converted result, the intermediate meters_per_second value, the dimensionless factor from source to target, a formula line you can show in a UI, a method label always equal to speed_si_factors, and units_supported listing the four canonical ids. If the source or target token is missing, empty, or not among the supported aliases, the engine raises invalid_input with a message that includes the unrecognized unit and the supported list—those failures are not charged after validation rejects the request. Field aliases value, amount, speed, and quantity for the number, and unit, unit_from, source plus unit_to and target for the units, match common form and API naming so you rarely need a thin adapter layer.

API usage, pricing, travel workflows, and practical limits

Call the free in-browser speed unit converter when you are planning a road trip across metric and imperial regions, checking a boat’s knot reading against a road speed limit, or converting a sensor sample in meters per second for a presentation. Source inputs follow the same retention rules as other KIT parse items, and results are safe to pin in tests because the algorithm is fully deterministic. Authors shipping SDKs can map the all object directly into multi-column tables and use the formula string for expandable “show math” panels without reimplementing statute versus nautical mile factors in every client language. Post a JSON body with the required number value and the string fields from and to. Use the prepaid API when a travel app, aviation briefing tool, logistics platform, or fitness export pipeline needs a stable contract under KIT balance at $0.002 per successful item. Pair this endpoint with trip fuel or range calculators when the next step is cost or distance, and keep unit labels visible so users never confuse knots with kilometers per hour. Extremely large magnitudes may overflow IEEE floating point and fail with invalid_input; ordinary travel speeds from walking pace to commercial airliners fit comfortably.

Integration use cases

Telemetry and sensor pipelines

Normalize vehicle or device speeds stored in m/s into km/h or mph for dashboards, exports, and customer-facing reports through a single deterministic endpoint.

Technical questions

How do I convert 100 km/h to mph?

Send JSON with value: 100, from: "km/h", and to: "mph". The response includes result in mph, meters_per_second, and an all map with every supported unit.

Read the full KIT documentation →

Run — free