Unix Millisecond Micro-Timestamp Inspector

Paste a raw stack of Unix epoch integers and instantly detect precision, convert to ISO 8601 UTC and local time, and isolate latency variations with per-row delta time analysis.

● Auto-Detect Precision △ Delta Time Analysis 🔒 100% Client-Side
Looking to convert a single timestamp? Try the Unix Epoch Converter or the Unix Epoch Converter (extended) for single-entry lookups. This inspector is optimized for bulk stacks and delta analysis.
Panel 1
📋 Data Stack Injection
Waiting for input...
ms
Panel 3
📈 Stack Telemetry
Total Timestamps Parsed
0
valid epoch integers
Min Delta Detected
-
-
Max Delta Detected
-
-
Epoch Range Spanned
-
Panel 2
📋 Epoch Inspection Matrix
SEC 10-digit seconds
MS 13-digit milliseconds
US 16-digit microseconds
NS 19-digit nanoseconds
# Raw Epoch Integer Precision UTC / ISO 8601 Local Time Delta (dt) from Previous
▴
Paste epoch integers in Panel 1 to populate the inspection matrix.
Key Terms: Unix Epoch and High-Precision Timestamp Glossary
Unix Epoch
The universal reference point for Unix time: January 1, 1970, at 00:00:00 UTC. All Unix timestamps count elapsed seconds (or fractions) from this moment.
Millisecond (ms)
One one-thousandth of a second (0.001 s). Unix millisecond timestamps are 13-digit integers. Used in web APIs, JavaScript Date objects, and most application logging systems.
Microsecond (us)
One one-millionth of a second (0.000001 s). Unix microsecond timestamps are 16-digit integers. Used in database engines, kernel event logs, and network packet captures.
Nanosecond (ns)
One one-billionth of a second. Unix nanosecond timestamps are 19-digit integers, exceeding JavaScript Number precision and requiring BigInt or 64-bit integer arithmetic for safe handling.
ISO 8601
The international standard date and time format (e.g. 2024-06-14T18:30:00.000Z). The trailing Z denotes UTC. This inspector outputs all UTC times in ISO 8601 format for maximum portability.
Delta Time (dt)
The elapsed time between two consecutive events. In this inspector, the Delta column shows the time gap between each row and the row above it. Large or irregular deltas indicate latency spikes, dropped events, or clock errors.
Year 2038 Problem
A software bug affecting systems that store Unix timestamps in a signed 32-bit integer. On January 19, 2038, the value overflows to a large negative number. 64-bit and BigInt systems are unaffected.
High-Frequency Trading (HFT)
Automated trading strategies that execute thousands of orders per second. HFT systems rely on microsecond and nanosecond timestamps to measure and minimize order execution latency.

The Complete Guide to Unix Epoch Timestamp Precision and Delta Analysis

Whether you are debugging a high-frequency trading log, analyzing server telemetry, tracing a distributed system, or auditing a data pipeline, raw epoch integers are rarely human-readable and almost never carry their own unit label. This inspector solves both problems simultaneously: it detects what unit each integer is in, converts it to a readable date, and then computes the time gap between every consecutive pair of entries so you can spot anomalies without writing a single line of code.

How to Use This Tool

Copy your batch of epoch timestamps from any source: a log file, a database query result, a CSV export, a trading system feed, or a packet capture. Paste one integer per line into the Data Stack Injection panel on the left. The Inspection Matrix fills immediately with no submit button required. Each row shows the raw integer, its auto-detected precision tier, the UTC date in ISO 8601 format, your local browser time, and the delta from the row above. If any delta exceeds your configured warning threshold, it is highlighted in amber so it stands out at a glance. You can also use the Sort Chronologically toggle to re-order an out-of-sequence stack before analyzing deltas.

Why Precision Detection from Integer Length Works

The digit-count method works because each precision tier covers a distinct numeric range for any timestamp in the modern era. Second-precision timestamps from the year 2000 through 2100 all fall between 946,684,800 and 4,102,444,800: exactly 10 digits. Multiply by 1,000 (milliseconds) and you get 13 digits. Multiply by 1,000,000 (microseconds) and you get 16 digits. Multiply by 1,000,000,000 (nanoseconds) and you get 19 digits. These tiers do not overlap for dates between approximately 1970 and 2255, making digit length a reliable precision signal without needing any metadata or schema.

BigInt Safety for Microsecond and Nanosecond Math

JavaScript's standard Number type uses 64-bit IEEE 754 floating-point, which can only represent integers exactly up to 2^53 - 1 (about 9 quadrillion). A microsecond timestamp for today is roughly 1,718,000,000,000,000 (16 digits), which is already within the Number.MAX_SAFE_INTEGER limit, but nanosecond timestamps (19 digits) exceed it and would silently lose precision. This inspector uses JavaScript BigInt for all delta calculations involving 16-digit or 19-digit timestamps, converting to BigInt before subtraction and back to a regular number only after scaling down to a safely representable unit for display.

Reading the Delta Column for Anomaly Detection

The Delta column is where the real diagnostic value lives. In a healthy real-time event stream, the delta between consecutive entries should be small and consistent. A delta that is zero (or near-zero) may indicate duplicate events or a timestamp collision. A delta that is much larger than the average may indicate a dropped event, a processing delay, a clock adjustment, or a gap in the data source. The amber warning highlight makes these outliers immediately visible. The Telemetry panel also shows the global minimum and maximum delta across the entire stack so you can calibrate your threshold appropriately.

FAQ: Unix Epoch, Timestamp Precision, and Delta Analysis

The Unix Epoch is the reference point used by Unix operating systems to measure time as a single, continuously incrementing integer. It was set to January 1, 1970, at 00:00:00 UTC because that date was close to the creation of Unix at Bell Labs, fell conveniently at the start of a year, and was recent enough to keep timestamp values small enough for early 32-bit systems to handle. Every second that passes since that moment is added to the Unix timestamp counter, making it a universal, timezone-independent way to record any moment in time.
The inspector uses the integer digit length of each timestamp to determine its precision magnitude. A 10-digit integer represents seconds (valid roughly 2001-2286). A 13-digit integer represents milliseconds (1000x seconds). A 16-digit integer represents microseconds (1,000,000x seconds). A 19-digit integer represents nanoseconds. This digit-count method is reliable because each precision tier shifts the numeric range by exactly three orders of magnitude, creating a non-overlapping set of digit lengths for timestamps covering the modern era. You can also override auto-detection using the Force Precision dropdown.
The time delta (change in time) between consecutive timestamps in a data stack reveals the rhythm of the underlying system that generated the data. In high-frequency trading, delta analysis exposes order book update latency and execution jitter. In server telemetry, unexpectedly large deltas indicate event processing delays or dropped packets. In sensor data, irregular deltas signal hardware sampling errors or clock skew. By highlighting delta values that exceed a user-defined threshold, the inspector lets you instantly identify outlier events that would be invisible when looking at raw epoch integers alone.
The Year 2038 problem affects systems that store Unix timestamps as a signed 32-bit integer. That data type can hold a maximum value of 2,147,483,647, which corresponds to January 19, 2038 at 03:14:07 UTC. After that moment, a 32-bit signed counter overflows and wraps to a large negative number, causing dates to be misread as 1901. Millisecond timestamps are much larger numbers and already require at least 41 bits to represent correctly, so any system using millisecond precision must already be using 64-bit integers (or BigInt in JavaScript), making them immune to the 2038 overflow. Microsecond and nanosecond timestamps require even more bits and are always handled with 64-bit types.
Operating systems generate high-resolution timestamps by querying a hardware clock source that ticks faster than once per millisecond. On Linux, the CLOCK_REALTIME and CLOCK_MONOTONIC sources accessed via clock_gettime() can return nanosecond-resolution values sourced from the CPU's Time Stamp Counter (TSC) or a hardware clock chip. Windows uses QueryPerformanceCounter() backed by the HPET or TSC. In JavaScript, performance.now() provides sub-millisecond resolution capped at 1 microsecond in modern browsers. In high-frequency trading environments, dedicated network interface cards with hardware timestamping can record arrival times of market data packets with accuracy under 100 nanoseconds.