Sample GPX File Download

GPX (GPS Exchange Format) is a lightweight, XML-based data schema for the interchange of geographic data (waypoints, routes, and tracks) between software applications and GPS devices. It serves as the universal language for outdoor navigation, sports tracking, and logistics mapping.

Technical Advantages of the GPX Format

Since its inception by Topografix, GPX has become the de facto standard because of its flexibility. It allows for the storage of not just coordinates (Latitude and Longitude), but also altitude, time, and heart rate data, making it essential for modern fitness apps like Strava and Garmin Connect.

• Open XML Standard: Easily readable by any XML parser, making it developer-friendly and future-proof.
• High-Precision Metadata: Supports WGS84 datum, ensuring that your tracks and waypoints align perfectly with global mapping standards.
• Universal Compatibility: Works natively with Google Earth, QGIS, ArcGIS, and specialized outdoor GPS devices (Garmin, Suunto, etc.).

For deep technical specifications, refer to the Topografix GPX Reference Guide or explore the GPX historical background .

GPX files are used by fitness apps, mapping tools, and GPS devices. Below are four complete, runnable examples for the most common workflows — from parsing tracks in Python to importing waypoints into a web map.

How to Parse a GPX File in Python (gpxpy)

The gpxpy library is the most widely used Python tool for reading GPX files. It parses the entire file into a structured object with tracks, routes, and waypoints accessible as properties.

import gpxpy

with open("sample-hiking-track.gpx", "r") as f:
    gpx = gpxpy.parse(f)

# Iterate through all tracks and points
for track in gpx.tracks:
    print(f"Track: {track.name}")
    for segment in track.segments:
        for point in segment.points:
            print(f"  Lat: {point.latitude}, Lon: {point.longitude}, Ele: {point.elevation}m")

How to Parse a GPX File in JavaScript (DOMParser)

Since GPX is XML, the browser's built-in DOMParser can parse it without any additional libraries. This is ideal for map visualization tools that run entirely in the browser.

fetch("/sample-hiking-track.gpx")
  .then((res) => res.text())
  .then((gpxString) => {
    const parser = new DOMParser();
    const doc = parser.parseFromString(gpxString, "application/xml");

    const trackPoints = doc.getElementsByTagName("trkpt");
    Array.from(trackPoints).forEach((pt) => {
      const lat = pt.getAttribute("lat");
      const lon = pt.getAttribute("lon");
      const ele = pt.querySelector("ele")?.textContent;
      console.log(lat + ", " + lon + " @ " + ele + "m");
    });
  });

How to Import a GPX File into QGIS

Open QGIS and go to Layer > Add Layer > Add Vector Layer. Set the Source Type to File, click Browse, and select your .gpx file. QGIS will show a dialog asking which GPX layer types to load — select tracks, routes, or waypoints depending on what your sample file contains. Each type becomes a separate layer in the project.

How to Visualize a GPX Track on an Interactive Map (Leaflet)

// Using Leaflet.js + leaflet-gpx plugin
// <script src="https://unpkg.com/leaflet/dist/leaflet.js"></script>
// <script src="https://unpkg.com/leaflet-gpx/gpx.js"></script>

const map = L.map("map").setView([35.595, -82.551], 14);
L.tileLayer("https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png").addTo(map);

new L.GPX("sample-hiking-track.gpx", {
  async: true,
  marker_options: { startIconUrl: null, endIconUrl: null, shadowUrl: null },
})
  .on("loaded", (e) => map.fitBounds(e.target.getBounds()))
  .addTo(map);

GPX files are XML documents that follow a strict schema defined by the GPX 1.1 specification. Creating one manually requires understanding the three primary element types: wpt (waypoint), rte and rtept (route), and trk, trkseg, and trkpt (track).

Creating a GPX File Manually in a Text Editor

Every GPX file must declare the namespace and version in the root element. Latitude and longitude are attributes on each point element, not child elements. Elevation and time are optional child elements.

<?xml version="1.0" encoding="UTF-8"?>
<gpx version="1.1" creator="MyApp"
     xmlns="http://www.topografix.com/GPX/1/1">
  <trk>
    <name>My Morning Run</name>
    <trkseg>
      <trkpt lat="51.5074" lon="-0.1278">
        <ele>15.0</ele>
        <time>2024-03-28T08:00:00Z</time>
      </trkpt>
      <trkpt lat="51.5080" lon="-0.1285">
        <ele>16.2</ele>
        <time>2024-03-28T08:01:00Z</time>
      </trkpt>
    </trkseg>
  </trk>
</gpx>

Generating a GPX File in Python (gpxpy)

import gpxpy
import gpxpy.gpx
from datetime import datetime, timezone

gpx = gpxpy.gpx.GPX()
track = gpxpy.gpx.GPXTrack(name="My Morning Run")
gpx.tracks.append(track)
segment = gpxpy.gpx.GPXTrackSegment()
track.segments.append(segment)

points = [
    (51.5074, -0.1278, 15.0),
    (51.5080, -0.1285, 16.2),
    (51.5086, -0.1290, 17.0),
]
for lat, lon, ele in points:
    segment.points.append(
        gpxpy.gpx.GPXTrackPoint(lat, lon, elevation=ele,
                                time=datetime.now(timezone.utc))
    )

with open("output.gpx", "w") as f:
    f.write(gpx.to_xml())

Common mistakes to avoid: Always use the WGS84 coordinate system — latitude and longitude in decimal degrees, not degrees-minutes-seconds format. The namespace declaration on the root gpx element is mandatory; omitting it will cause many tools to reject the file. Timestamps must be in ISO 8601 format with UTC timezone (Z suffix). Never swap latitude and longitude — the order is always latitude first, then longitude.