Unix Timestamp Converter Online — Free Epoch to Date Tool

Convert Unix epoch timestamps to ISO 8601, UTC, RFC 2822, and local time — and back. Auto-detects seconds, milliseconds, microseconds, and nanoseconds. 100% in your browser, no upload.

Timestamp → Date

Paste a Unix timestamp — seconds, ms, μs, or ns are auto-detected.

Date → Timestamp

Pick a date and time — Unix epoch is computed in all four precisions.

What is a Unix Timestamp Converter?

A Unix timestamp converter translates between an integer count of time units since the Unix epoch (1970-01-01T00:00:00Z) and a human-readable date. It is the bread-and-butter tool for anyone debugging logs, designing APIs, querying databases, or building anything that stores time as a number.

The OpenFormatter converter auto-detects four precisions — seconds (10 digits), milliseconds (13), microseconds (16), and nanoseconds (19) — and renders ISO 8601, RFC 2822, UTC, and local-time representations side by side. A reverse panel converts a date you pick back to all four epoch precisions, and Bulk mode crunches an entire pasted list at once.

How to use the Unix timestamp converter — 4 steps

Paste a timestamp. Drop the integer into the timestamp field. The digit count tells the tool whether it's seconds, ms, μs, or ns — no manual switch needed.
Read every representation. The output shows ISO 8601 (UTC), RFC 2822, UTC long form, and your local time, plus the same instant in the other three precisions.
Or go the other way. Pick a date with the datetime picker; the right panel emits Unix seconds, ms, μs, and ns ready to paste into code or SQL.
Convert in bulk. Switch to Bulk mode, paste one timestamp per line, and the table renders the ISO date for every row — handy for log forensics or CSV cleanup.

Sample input and output

Input  (seconds, 10 digits): 1714471234
        ISO 8601 (UTC):       2024-04-30T08:40:34.000Z
        RFC 2822:             Tue, 30 Apr 2024 08:40:34 GMT
        Milliseconds:         1714471234000
        Nanoseconds:          1714471234000000000

Input  (milliseconds, 13):    1714471234567
        ISO 8601 (UTC):       2024-04-30T08:40:34.567Z

Input  (nanoseconds, 19):     1714471234567890000
        ISO 8601 (UTC):       2024-04-30T08:40:34.567Z

Two-Way Conversion

Timestamp to date and date to timestamp in one screen — covering all four precisions used in the wild.

Auto Precision Detect

Digit count maps to seconds, ms, μs, or ns automatically. No need to remember which precision your stack uses.

Bulk Mode

Paste a column of timestamps from a log file or CSV; get a table of ISO dates and detected precision back instantly.

Common use cases

check_circleDebugging server log entries that store created_at as Unix seconds
check_circleTranslating Kafka, Kinesis, or Pub/Sub event timestamps for replay analysis
check_circleReading PostgreSQL TIMESTAMP, MySQL UNIX_TIMESTAMP(), and Redis EXPIRE values
check_circleInspecting JWT iat / exp / nbf claims (Unix seconds per RFC 7519)
check_circleConverting JavaScript Date.now() ms output to seconds for a backend API
check_circleDecoding Go time.UnixNano nanosecond traces from distributed systems
check_circleAuditing AWS CloudTrail, GCP audit logs, and Azure activity timestamps
check_circleSetting cron schedules and verifying scheduled-job fire times

Why store dates as Unix timestamps?

A Unix timestamp is a single signed integer that represents the same instant in every time zone, on every platform, in every language. It sorts, compares, and arithmetically subtracts trivially — "how long ago was this?" is one minus operation. It avoids the entire surface area of string-format ambiguity (DD/MM vs MM/DD, slashes vs dashes, locale month names) that plagues human-readable formats. The trade-off is that a raw integer is meaningless to humans, which is exactly the gap this converter fills: store epoch in your database, render ISO 8601 at the API edge, and use this tool when you need to inspect a value mid-debug.

Working with dates beyond conversion?

Validate, format, and compare dates with the rest of OpenFormatter's DateTime toolkit — all browser-side.

ISO 8601 Validator Time Zone Converter Date Format Converter

Frequently Asked Questions

What is Unix epoch time?

Unix epoch time (also called POSIX time or Unix timestamp) is the number of seconds elapsed since 1970-01-01T00:00:00Z, not counting leap seconds. It is the universal way to store moments in time inside Unix-derived systems, databases, log files, and almost every programming language. A timestamp of 0 means midnight UTC at the start of 1970; 1000000000 was September 9, 2001.

Why is my timestamp 13 digits?

13 digits means milliseconds since the epoch — the precision JavaScript Date.now() returns. 10 digits is seconds (the original Unix convention used by C, Python time(), Go, and PostgreSQL TIMESTAMP), 16 digits is microseconds (Python time.time_ns()/1000, PostgreSQL extract(epoch)*1e6), and 19 digits is nanoseconds (Go time.UnixNano, Java Instant.toEpochNano). This converter detects the digit count and picks the right precision automatically.

What is the Y2038 problem?

The Y2038 problem is the moment a 32-bit signed integer storing Unix seconds overflows: 03:14:07 UTC on January 19, 2038 (2147483647 seconds). Systems still using time_t as int32 will wrap to a negative number and interpret the time as 1901. Modern Linux, macOS, BSD, and 64-bit kernels use int64 time_t, which does not overflow for ~292 billion years. Embedded devices and old binaries are the remaining risk.

Are negative timestamps valid?

Yes — a negative Unix timestamp represents a date before 1970-01-01 UTC. -1 is 1969-12-31T23:59:59Z, -2208988800 is 1900-01-01. JavaScript Date handles negative epoch values correctly, and so does this converter when you paste a leading minus sign. Many databases and APIs reject them in their schema validation, however, so check before storing historical events as negative epochs.

How do I get the current Unix time in different languages?

JavaScript: Math.floor(Date.now()/1000) for seconds, Date.now() for ms. Python: int(time.time()) or time.time_ns(). Go: time.Now().Unix() or .UnixNano(). PostgreSQL: extract(epoch from now()). Bash: date +%s (or date +%s%3N for ms). Java: Instant.now().getEpochSecond() / .toEpochMilli(). Click the Now button above to see the current epoch in this tool.

What is the difference between epoch in seconds vs milliseconds?

They count the same instant but at different precisions. Seconds give whole-second resolution (1714471234), milliseconds give thousandths (1714471234567). Convert by multiplying or dividing by 1000. JavaScript natively works in ms, most Unix tools in seconds. Mixing them is the most common bug — a 13-digit value passed where 10 is expected lands you in the year 56000.

Can I convert milliseconds back to seconds losslessly?

Going from ms → seconds always loses sub-second precision (1714471234567 ms truncates to 1714471234 s — the .567 ms is gone). Going seconds → ms appends three zeros and is lossless because seconds had no sub-second info to lose. The same applies between ms/μs and μs/ns: divide loses precision, multiply preserves.

How accurate are Unix timestamps?

A Unix timestamp is an exact integer count of SI seconds (or smaller units) and is therefore as precise as the source clock. The browser Date object is millisecond-accurate, performance.now() is microsecond, and OS-level monotonic clocks reach nanoseconds. Wall-clock accuracy depends on NTP sync — most servers stay within a few ms of UTC. Leap seconds are not counted, so during a leap insertion the timestamp briefly stalls.