How Fast Do Planes Fly? Cruise, Take-off and Landing Speeds Explained

A typical airliner cruises at about 520 to 570 mph, or 840 to 920 km/h. It takes off at roughly 150 to 190 mph and lands at around 150 to 170 mph. Those are the short answers.

The longer answer is that "speed" means three different things in aviation, and they can differ by hundreds of miles an hour on the same flight. That's why a flight tracker can show a 787 doing 800 mph when the aircraft is nowhere near its limits. This post explains the three speeds, gives real numbers for each phase of flight, and shows how to read speed from live flight data.

The numbers, phase by phase

A small training aircraft like a Cessna 172 lifts off at about 55 knots and cruises at around 120. Concorde cruised at Mach 2.04, about 1,350 mph, until it was retired in 2003.

The 250-knot figure isn't a performance limit. It's a rule: in the US, aircraft must fly no faster than 250 knots below 10,000 feet, and many other countries have the same limit in most of their airspace. It keeps speeds manageable where traffic is dense and birds are common.

Three kinds of speed

Indicated airspeed is what the pilot's airspeed indicator shows. It measures the pressure of the air rushing into a forward-facing tube, so it reflects how much air the wing is actually meeting. That's what matters for flying: the aircraft stalls and reaches its structural limits at roughly the same indicated speed at any altitude. Take-off, approach and the 250-knot limit are all indicated airspeeds.

True airspeed is how fast the aircraft moves through the air mass. At altitude the air is thin, so the aircraft has to move much faster to get the same pressure in the tube. An airliner at 35,000 feet might show around 280 knots indicated while moving at 480 knots true.

Ground speed is how fast the aircraft moves over the ground. It's true airspeed plus or minus the wind. This is what flight trackers show, and it's what decides when you land.

Then there's Mach number, the ratio of true airspeed to the local speed of sound. High up, airliners fly by Mach rather than knots, because the limits that matter there have to do with air flowing over the wing approaching the speed of sound. Sound travels at about 661 knots at sea level on a standard day, but only about 576 knots at 35,000 feet, because the air is colder up there.

That makes the conversion depend on altitude:

import math

def speed_of_sound_kt(altitude_ft):
    """ISA temperature falls 1.98 C per 1,000 ft up to 36,089 ft, then stays at -56.5 C."""
    temp_c = 15 - 1.98 * min(altitude_ft, 36_089) / 1000
    return 38.967 * math.sqrt(temp_c + 273.15)

def mach_to_ktas(mach, altitude_ft):
    return mach * speed_of_sound_kt(altitude_ft)

mach_to_ktas(0.78, 35_000)   # ~450 knots, about 517 mph: a 737 or A320
mach_to_ktas(0.85, 35_000)   # ~490 knots, about 564 mph: a 787 or A350

The standard atmosphere is an average. On a warm day the speed of sound at cruise is a bit higher, so the same Mach number gives a slightly higher true airspeed.

Which airliners are fastest?

Narrowbodies such as the Boeing 737 and Airbus A320 families typically cruise around Mach 0.78 to 0.79. Long-haul widebodies are faster: the 787, A350 and 777 usually cruise around Mach 0.84 to 0.85, and the 747 is a little faster again, at about Mach 0.85 to 0.86.

Why not faster still? Fuel. Drag climbs steeply as you approach the speed of sound, so flying a few percent faster costs a lot more fuel. Airlines often cruise slightly below an aircraft's fastest economical speed when fuel is expensive, and pick it up again when they need to recover a delay.

Why trackers show 800 mph

When the jet stream is strong, ground speed and true airspeed come apart. An aircraft moving through the air at 560 mph inside a 200 mph tailwind covers the ground at 760 mph.

The records come from winter jet streams over the North Atlantic and the eastern US. In February 2019, a Virgin Atlantic 787 was reported at 801 mph ground speed over Pennsylvania. A year later, a British Airways 747 passed 800 mph during Storm Ciara and crossed from New York to London in 4 hours 56 minutes. Neither aircraft broke the sound barrier. Relative to the air around them, they were flying normally.

The same thing works in reverse. A westbound flight into that jet stream can show a ground speed in the low 400s while cruising at its usual Mach number. If you've noticed that flights take longer going west, this is why.

Reading speed from live data

ADS-B, the system aircraft use to broadcast their position, includes ground speed. The live ADS-B endpoint returns it in knots for each aircraft and lets you filter by it, which makes "what's flying fastest right now?" a single request:

import requests

BASE = "https://skylink-api.p.rapidapi.com"
H = {"X-RapidAPI-Key": KEY, "X-RapidAPI-Host": "skylink-api.p.rapidapi.com"}

def get(path, **params):
    r = requests.get(f"{BASE}{path}", headers=H, params=params, timeout=20)
    r.raise_for_status()
    return r.json()

def fastest_over(bbox, min_speed=550, top=10):
    data = get("/adsb/aircraft", bbox=bbox, min_speed=min_speed, min_alt=25_000)
    planes = [a for a in data["aircraft"] if a.get("ground_speed") is not None]
    return sorted(planes, key=lambda a: a["ground_speed"], reverse=True)[:top]

fastest_over("49,-15,60,2")   # Ireland and the UK: SW corner, then NE

The min_alt filter matters. Without it, you'd also pick up the occasional glitchy low-altitude position with an impossible speed, which flight data quality covers.

You can go a step further and estimate the wind each aircraft is riding. Take its ground speed and subtract its type's typical cruise speed from the aircraft performance endpoint:

import re

DESIGNATOR = re.compile(r"\b([A-Z][A-Z0-9]{1,3})$")

def wind_effect(plane):
    """Ground speed minus typical cruise TAS: a rough tailwind (+) or headwind (-)."""
    m = DESIGNATOR.search(plane.get("aircraft_type") or "")
    if not m:
        return None
    try:
        perf = get(f"/aircraft/performance/{m.group(1)}")
    except requests.HTTPError:
        return None
    return round(plane["ground_speed"] - perf["cruise_speed_ktas"])

The aircraft_type field on the live feed is sometimes a bare designator like B77W and sometimes a string like "Boeing B738", so the pattern pulls the code off the end. When neither works, the aircraft lookup by hex address returns a clean icao_type. The type-code post, ICAO aircraft type designators explained, covers those codes.

Treat the result as a rough number. The cruise speed is typical for the type, not what this particular flight is doing, and ground speed includes the direction of the wind relative to the track, not just its strength. For real winds at altitude, the winds aloft endpoint gives the forecast directly.

Quick reference

• 1 knot = 1.151 mph = 1.852 km/h. Aviation uses knots because a nautical mile is one minute of latitude, which makes navigation arithmetic simpler.
• Typical cruise: Mach 0.78 (narrowbody) to Mach 0.85 (widebody), about 520 to 565 mph true airspeed.
• Ground speed on a tracker = true airspeed ± wind. Over 700 mph means a strong tailwind, not a supersonic airliner.
• Indicated airspeed is the one pilots fly by, and it's always lower than true airspeed at altitude.

If you want to try the live feed or the performance data yourself, you can apply for the free trial, which covers personal, non-commercial projects. Commercial products need a paid plan.