Unix Timestamp Converter
Two-way Unix timestamp conversion between epoch seconds and human-readable dates.
Every system that stores time needs a compact number it can sort and compare, and for decades that number has been the Unix timestamp: seconds since 1970-01-01 00:00:00 UTC. Useful in databases and logs, it is nearly unreadable to humans - 1752652800 means nothing until you know the epoch. This converter translates in both directions.
Paste a timestamp and get the date in seconds or milliseconds precision, in UTC and your local time zone, plus ISO 8601 and RFC 2822 renderings. Type a date and get its timestamp back. The two panes stay in sync, and a live clock shows the current timestamp ticking so you can grab it on the spot.
The conversions run entirely in your browser using the built-in JavaScript Date machinery. Nothing you paste is uploaded or stored, which makes the tool safe for timestamps plucked from production logs or API responses that have not been scrubbed.
Features
- Convert timestamp to date and date to timestamp in one view.
- Seconds and milliseconds inputs, with auto-detection of the magnitude.
- UTC and local time zone output side by side.
- ISO 8601, RFC 2822 and locale strings for every converted value.
- Live clock showing the current Unix timestamp in seconds and milliseconds.
- Handles timestamps far outside the common range.
- Fully offline - nothing leaves your browser.
How to Use
- 1
Enter a timestamp
Paste seconds or milliseconds in the timestamp field. The magnitude is detected automatically.
- 2
Read the date
See the converted moment in UTC and your local time, with ISO 8601 and RFC 2822 formats beneath.
- 3
Go the other way
Type a date and time, or use the Now button to capture the current moment, and read the matching timestamp.
- 4
Copy what you need
Copy the seconds, milliseconds or any formatted string with the copy button next to each value.
Example
A production timestamp
1752652800↓
2026-07-16 00:00:00 UTC (local time shown in your zone)Current moment
Now → 2026-08-15 12:00:00 local↓
Seconds: 1773xxxxxx · Milliseconds: 1773xxxxxxxxxxCommon Problems
Seconds versus milliseconds
The two ranges overlap: a millisecond timestamp of 1752652800000 is close to a second timestamp of 1752652800. The tool detects magnitude and assumes seconds under 10 digits, milliseconds at 13 or more.
Timezone confusion
A Unix timestamp is a moment in time with no zone. It converts to 2026-07-16 00:00 UTC and to whatever that is in your local zone. If a value looks "off by hours", the other end is almost certainly rendering it in a different zone.
Timestamps before the epoch
Negative timestamps represent dates before 1970 and are valid. The converter handles them correctly; if a value renders as 1969, the source system may be feeding seconds where milliseconds were expected.
Floating seconds
Some systems emit fractional seconds. The converter accepts the integer part and can report sub-second precision where relevant; truncating decimals in logs is a common silent bug source.
Using the wrong year range
JavaScript dates cover roughly the years 1970 to 275760 with full precision. Timestamps far beyond that range may not round-trip; for historical data older than the epoch, the numeric conversions still hold.
Confusing UTC and Unix
UTC is a time standard; Unix time is an instant measured as seconds since the epoch. They are related but not interchangeable - this tool keeps the distinction explicit in its output labels.
Leap seconds in measurement
Real time adds leap seconds occasionally, but Unix time ignores them, so a timestamp is not the exact count of physical seconds since the epoch. For everything except the most exacting astronomy work the difference is irrelevant.
Mixing the tool with 32-bit libraries
Some older libraries still store timestamps as 32-bit integers, which overflow in 2038. The converter itself is fine; if you feed its output into a 32-bit field, plan for the wrap-around.
Technical Details
A Unix timestamp is the number of seconds since 1970-01-01T00:00:00Z, ignoring leap seconds. This tool converts using the platform Date implementation, which models standard wall-clock time.
Magnitude detection works from the digit count: values with 10 digits are treated as seconds, 13-digit values as milliseconds, and the tool also accepts explicit manual switching.
UTC output uses the ISO 8601 representation with a Z suffix; local output uses the same format with the zone offset substituted, so the two are directly comparable.
ISO 8601, RFC 2822, and the locale string formats are all derived from the same underlying Date object, so every row describes the identical moment.
The tool detects magnitude by digit count but never silently drops precision: a 16-digit value is treated as a full-precision millisecond timestamp and converted exactly.
Output rows are computed from a single parsed Date, so seconds, milliseconds and the formatted strings all describe the identical instant and cannot drift from one another.
All conversion is local and synchronous, using only the browser runtime. No request is made and no input is logged.
Frequently Asked Questions
What is a Unix timestamp?
The number of seconds elapsed since 1970-01-01 00:00:00 UTC, not counting leap seconds. It is the standard compact representation of an instant used by operating systems and databases.
Why is my timestamp ten digits but mine is thirteen?
Thirteen-digit values are milliseconds. Many modern APIs and JavaScript Date use milliseconds while databases and shell tools default to seconds. The converter detects the magnitude for you.
Is the output in my time zone?
You get both. The tool always shows the UTC reading and the local reading for the same instant, so you can see exactly how the zone offset is applied.
Can a timestamp be negative?
Yes - a negative timestamp means a moment before the epoch, such as 1969. The converter renders those correctly, which matters when debugging legacy data.
Does this tool upload my timestamps?
No. Conversion runs entirely in your browser. The values you paste are processed in memory and never transmitted, stored or logged.
Does it handle the year 2038 problem?
The tool uses the modern Date implementation, which is not limited to 32-bit seconds, so 2038 and beyond convert fine. Only a 32-bit storage layer would overflow, and that is the database's concern, not the converter's.
Data & Privacy
Your data stays in your browser. Nothing is uploaded.
- Processing
- Local
- Upload
- None
- Server Storage
- None
- Account
- Not required
Related Tools
Cron Expression Generator
Assemble a cron expression from field selectors with a live description and next-run preview.
Time & Date
Timestamp Generator
Turn a chosen date and time into every common timestamp format at once.
Time & Date
Cron Expression Parser
Decode a cron expression into readable fields, a plain-English description and upcoming run times.
Time & Date
JSON Formatter
Format, validate and beautify JSON directly in your browser.
JSON & Data
Text Diff Checker
Line-by-line text comparison that shows every added, removed and unchanged line.
Regex & Text
Regex Tester
Test regex patterns against your text with live highlighting, capture groups and common-pattern shortcuts.
Regex & Text
Related Guides
Unix Timestamp Guide: Convert and Read Epoch Time
A Unix timestamp is the number of seconds since 1970-01-01 UTC. Convert one in the tool or in code, and understand the 2038 limit on 32-bit systems.
Epoch Time Explained: The Epoch, UTC and the Year 2038 Problem
Epoch time counts seconds since 1970-01-01 00:00:00 UTC. Learn why the epoch exists, why it is timezone-free, and how the 2038 problem works.
ISO 8601 Date Format Explained: What It Looks Like and How to Use It
ISO 8601 is the international date and time format, written like 2026-08-15T14:30:00Z. Learn how to read it, why the order matters and which form to store.