FIT Files Explained: The Runner's Guide to Watch Data

FIT stands for Flexible and Interoperable Data Transfer. It is a binary file format designed specifically for storing and sharing data from sport and fitness devices — every run, ride, lap, and sensor reading your watch records. The format was created by Dynastream Innovations, the Canadian company from Cochrane, Alberta that also invented the ANT+ wireless protocol used by heart rate straps and footpods. Garmin acquired Dynastream in 2006, and FIT became the recording format for the entire Garmin ecosystem. Because Garmin publishes a free, open FIT SDK at developer.garmin.com, the format spread far beyond one brand: COROS, Wahoo, Zwift, Stryd, Hammerhead, and most modern training devices now write FIT natively, and every serious analysis platform — Strava, TrainingPeaks, Runalyze, GoldenCheetah, Hashiri.AI — reads it.

FIT exists because the formats that came before it were built for the wrong job. GPX was designed in 2002 for exchanging GPS tracks between mapping programs — positions and timestamps, nothing about physiology. TCX, Garmin's earlier XML format, bolted on laps and heart rate but inherited XML's fundamental problem: text is enormous. A watch recording ten data fields every second for a three-hour marathon would produce a multi-megabyte XML file, painful to store on a 2008-era device with a few megabytes of memory and slow to transfer over ANT or early Bluetooth. FIT solved this with a compact binary encoding: each value is stored as raw typed bytes (a heart rate is one byte, a GPS coordinate four), with self-describing message definitions so any decoder can parse files from any device.

The result is a format that is small, extensible, and lossless — the closest thing to a 'RAW file' in endurance sports. When Strava, Garmin Connect, and TrainingPeaks show you different numbers for the same run, the FIT file is the ground truth they all started from. That is why this guide treats the FIT file as something worth understanding rather than a black box: it is the original record of your training, it transfers between platforms when you switch watch brands, and with the right (free) tools you can open, convert, repair, and analyze it yourself. Everything the platforms compute — pace charts, training load, VO2 max estimates — derives from the bytes described in the next section.

Every FIT file has three parts: a header, a stream of records, and a closing checksum. The header is 12 or 14 bytes and contains the protocol version, the profile version, the size of the data that follows, and the ASCII characters '.FIT' at bytes 8–11 — the signature tools use to recognize the format. The file ends with a 2-byte CRC that lets a decoder detect corruption. In between sits the actual data, organized as two kinds of records: definition messages and data messages. A definition message announces 'the following data messages of local type N contain these fields, in this order, with these byte sizes.' The data messages that follow are then pure values with no labels — which is exactly why FIT is so compact and why a text editor shows only gibberish. The decoder reconstructs meaning by pairing each data message with its definition.

The messages themselves are typed by a global message number defined in Garmin's FIT Profile. A typical activity file opens with a file_id message (device manufacturer, product, serial number, creation time), then streams thousands of record messages — one per second on most modern watches — each carrying that instant's GPS position, altitude, distance, speed, heart rate, cadence, power, and temperature. Lap messages summarize each lap split, event messages mark timer starts/stops, and a single session message at the end holds the totals your watch shows on the summary screen. Two details trip up first-time readers: FIT timestamps count seconds from December 31, 1989 UTC (not the Unix epoch), and GPS coordinates are stored in 'semicircles' — multiply by 180/2³¹ to get degrees.

FIT protocol 2.0 added developer fields, and they matter to runners more than the name suggests. A Connect IQ app or paired third-party sensor can define its own fields and write them into the same record stream: Stryd stores its running power, leg spring stiffness, and air power as developer fields; muscle-oxygen sensors and core-temperature sensors do the same. The file carries a field_description message explaining each custom field, so any compliant decoder can read them without prior knowledge. This is why a single FIT file can outlive any platform: whatever your watch and sensors measured on a given day — native or third-party — is preserved in one self-describing container.

Common FIT message types in an activity file

The three formats answer different questions. GPX (GPS Exchange Format) is an open XML standard from 2002 built to answer 'where did this track go?' — a list of trackpoints with latitude, longitude, elevation, and time. Heart rate, cadence, and temperature can ride along only inside optional extension tags (Garmin's TrackPointExtension is the common one), and support for those extensions varies by tool. TCX (Training Center XML) is Garmin's older training format and answers 'how did the workout go?' — it adds laps, per-point heart rate and cadence, calories, and sport type, but it is still verbose XML and predates running power, dynamics, and developer fields. FIT answers 'what did the device record?' — everything, including sensor metadata, R-R intervals, and custom fields, in a fraction of the size.

Size differences are dramatic because of the encoding. In FIT, one second of running data costs roughly 25–35 bytes; the same trackpoint in GPX or TCX costs several hundred bytes of angle brackets and decimal strings. For a one-hour run recorded every second, expect a FIT file around 100–300 KB, a GPX around 1–2 MB, and a TCX often larger still — roughly a 5–10x difference that grows with every extra sensor. Size matters less on modern phones than it did on 2008 watches, but it still shows up in practice: email attachment limits, upload speed for a 100-mile ultra file, and the simple fact that a decade of training history in FIT fits where one season of TCX would.

The practical rule: keep FIT as your archival format, and treat GPX and TCX as export targets for specific jobs. Share a route with a friend whose app only reads GPX? Export GPX. Feed an old tool that wants TCX? Export TCX. But never make GPX your only copy of an activity, because the conversion is one-way lossy — once laps, power, and device data are stripped, no converter can put them back. Every platform that matters accepts FIT uploads directly, so there is rarely a reason to convert before importing — converting first only risks losing fields the destination would have read happily. The comparison table below summarizes the trade-offs at a glance.

FIT vs GPX vs TCX at a glance

The fastest way to open a FIT file is an online viewer. Hashiri.AI's free FIT Viewer runs entirely in your browser: drop in a file and it renders the route map, pace/heart rate/elevation charts, and the full lap table — no account, no upload to a server, no install. That makes it the right tool for the common situations where you have a bare file and a question: a friend sent you their race file, you recovered an activity from a crashed watch, or you want to inspect what a file contains before uploading it somewhere. Browser-based viewers decode the same binary structure described above, so you see what the file actually stores rather than what a platform chose to recompute.

If you want the activity in your training history rather than just viewed, import it into a platform. Garmin Connect accepts FIT files via the Import button (cloud icon) on the web; Strava accepts them at strava.com/upload; TrainingPeaks, Runalyze, and intervals.icu all support drag-and-drop FIT import. Hashiri.AI does too — uploaded FIT files become full activities with maps, laps, and AI coach analysis. On desktop, GoldenCheetah is the power tool: a free, open-source analysis suite that reads FIT natively and exposes every field, including developer fields, for charting and export. GPXSee is a lightweight open-source viewer for quickly plotting the track and elevation profile of any FIT, GPX, or TCX file.

What does not work is opening the file directly in Excel, Numbers, or a text editor. FIT is binary: Excel expects delimited text and will show a wall of garbled characters, because the meaningful structure only emerges after decoding definition messages and applying the FIT Profile's field types and scaling factors (speed stored as mm/s, coordinates as semicircles, timestamps as a 1989-based epoch). To get FIT data into a spreadsheet you must convert it to CSV first — covered in the next section. Programmers can skip the converter entirely: Garmin's official FIT SDK ships decoders for JavaScript, Python (garmin-fit-sdk on PyPI), Java, C, and C#, and the community fitparse and fitdecode libraries are mature alternatives.

FIT to CSV is the conversion for anyone who wants to see the numbers. A good converter reads every record message and writes one row per second with columns like timestamp, latitude, longitude, distance, speed (or pace), heart rate, cadence, altitude, power, and temperature — plus developer-field columns such as Stryd power when present. Hashiri.AI's free FIT Converter does exactly this in the browser: drop in a FIT file, get a clean CSV, no account needed. From there a spreadsheet can answer questions no activity page will: average heart rate for a hand-picked stretch of the run, time spent above a cadence threshold, or a scatter plot of pace versus heart rate for one long run. CSV is also the honest interchange format for coaches and researchers, because nothing is hidden behind a platform's smoothing.

FIT to GPX is for sharing where the run went, and it is important to understand what survives the trip. Position, elevation, and timestamps convert cleanly. Heart rate, cadence, and temperature can be preserved in Garmin TrackPointExtension tags if the converter writes them — many minimal converters do not. What is always lost: laps and splits (GPX has no lap concept), running power, running dynamics, R-R intervals, calories, training effect, and device metadata. Convert to GPX when the destination is a mapping or navigation app, a race-route share, or an older platform that cannot read FIT. Do not use GPX as a backup format for training data — you are quietly throwing away most of the file.

GPX to FIT runs the conversion the other way, and the main reason runners need it is courses: Garmin and COROS watches navigate from FIT course files, so a route you drew in a mapping tool or downloaded from a race website as GPX must become FIT before the watch can guide you along it (Garmin Connect's course importer does this conversion implicitly; standalone converters like Hashiri.AI's GPX to FIT tool do it explicitly). Since GPX contains less than FIT, this direction is lossless — there is simply nothing to lose. One distinction matters: a course FIT and an activity FIT are different file types, so converting a finished run to GPX and back will not produce a navigable course unless the tool explicitly builds one. The decision table below maps common goals to the right conversion.

Which conversion do you need?

Raw FIT data settles arguments that platform charts cannot. GPS accuracy is the classic case: when your watch says 10.21 km and the race said 10 km, the per-second coordinates let you see exactly where the track wandered — under the start banner's buildings, through the tunnel, on the switchbacks — instead of guessing. Platforms also disagree with each other because each applies its own smoothing, elevation correction, and stopped-time logic to the same file; comparing the raw record stream against both versions shows you which platform changed what. And when a platform mangles an import (wrong distance, missing laps, halved power), the original FIT file proves whether the problem is your data or their parser — and gives you a clean copy to re-upload.

The raw stream also unlocks analyses most platforms still bury or paywall. Cardiac drift — aerobic decoupling — is the best example: split a steady long run in half, compute pace-to-heart-rate ratio for each half, and the percentage change tells you how durable your aerobic system is (commonly, under ~5% drift on a steady effort suggests solid aerobic endurance; more suggests the pace outran your fitness, heat, or fueling). With per-second data in a spreadsheet this is a ten-minute exercise. You can also examine pace smoothing directly: instantaneous GPS speed is noisy, and seeing the raw jitter explains why your watch's 'current pace' bounces around and why platforms display rolling averages. R-R interval data, when your strap records it, supports HRV analysis far beyond what the watch surfaces.

The flip side of all this richness is privacy. A FIT file is not just a route: the file_id message carries your device's serial number, the first record messages pin your exact start location — often your front door — and files can include user profile data such as weight, age, and gender that the watch uses for calorie math. Before posting a raw FIT file to a forum, sending it to a stranger, or attaching it to a bug report, trim the start/end of the track or use a tool that strips identifying messages, and check what profile fields are embedded. Platforms have privacy zones that hide your home on the map; a shared file bypasses all of them. Share screenshots freely, share files deliberately.

Garmin gives you three routes. Per activity: open the activity in Garmin Connect on the web, click the gear icon, and choose 'Export Original' — you get a ZIP containing the original FIT file exactly as the watch recorded it. In bulk: Garmin's account data export (the GDPR-style 'Export Your Data' request from your account management page) delivers your entire history, original FIT files included, within a couple of days. Directly: most Garmin watches still mount as USB storage, with activities sitting in the GARMIN/Activity folder as FIT files — the zero-cloud option. COROS exports per workout from the app: open the workout, tap the share/settings icon, choose 'Export Data', and select the .FIT format; the COROS web dashboard offers the same per-activity export.

Suunto's app exports FIT per activity as well: open the workout, tap the three-dot menu, and choose 'Download FIT file'. Polar is the outlier — Polar Flow's per-session export offers TCX, GPX, and CSV rather than FIT, and its full account export arrives as JSON, so Polar runners who need FIT must convert (TCX preserves the most). Apple Watch does not use FIT at all: workouts live in HealthKit's database. The established bridges are third-party apps — HealthFit and RunGap are the two most used — which read your HealthKit workouts and export them as standards-compliant FIT files (or sync them straight to Strava, TrainingPeaks, and similar platforms), GPS track, heart rate, and running power included.

Strava deserves a special mention because it often becomes a runner's accidental archive. For any single activity you uploaded from a device, the three-dot menu offers 'Export Original', which returns the exact file Strava received — FIT if it came from a Garmin/COROS/Wahoo sync. The account-level bulk export (Settings → My Account → Download or Delete Your Account → Download Request) packages your entire history with the original files. Two caveats: activities recorded with the Strava phone app have no FIT original (you will get GPX), and 'Export GPX' on a FIT-sourced activity gives you the lossy conversion, not the original. Whatever your platform mix, the durable habit is the same: keep a folder of original FIT files; platforms come and go, the format does not.

Corrupted files are the most stressful failure, usually after a watch crash or a battery death mid-activity: the file exists but the platform rejects it. The cause is almost always truncation — the recording stopped before the closing session message and final CRC were written, so strict parsers refuse the file. Recovery is very possible because FIT data records are self-contained: a repair tool re-reads the intact records, synthesizes the missing summary messages, and writes a valid file. The free web utilities at FIT File Tools include a corruption fixer plus a time adjuster, activity combiner, and section remover; GoldenCheetah will often import damaged files that other platforms reject; and Garmin's own SDK ships FitCSVTool, which can round-trip a file through CSV and back, regenerating valid structure along the way.

Two more everyday problems have data-level explanations. Missing or wild GPS at the start of a run happens when you press start before the watch has a satellite fix — the first record messages simply lack position fields, or contain a few hundred meters of scatter while the receiver converges; the fix is behavioral (wait for the fix indicator) but a section-remover tool can crop the garbage from an existing file. Merging two activities — your watch died, you finished on your phone, and you want one run — is what combiner tools do: they concatenate the record streams and rebuild a single session. Wrong timestamps usually trace to the format itself: FIT stores all timestamps in UTC and lets the displaying platform localize them, so an activity that appears shifted by exact hours is a timezone interpretation bug (or a watch that lost time sync), fixable with a time-adjuster tool rather than re-recording.

Finally, the eternal question: why does every platform show different elevation gain for the same file? Because elevation has three sources of truth. Watches with barometric altimeters (most mid-range and up Garmin and COROS models) record pressure-derived altitude in the FIT file — smooth and relatively trustworthy, though weather fronts and unsealed sensor ports can skew it. GPS-only devices record satellite-derived elevation, which is noisy enough that summing its ups and downs inflates gain badly. So platforms like Strava apply DEM correction — replacing recorded elevation with values looked up from a terrain elevation database along your track — for non-barometric devices, and sometimes optionally for all. Same FIT file, three defensible answers. When comparing runs, compare within one platform and one method; when auditing a single run, the raw altitude column in the FIT file shows what was actually recorded before anyone corrected it.