Unix Timestamp Converter
Paste an epoch integer and get the date, in UTC and your own timezone — with the unit detected rather than assumed, because seconds mistaken for milliseconds is how these conversions actually go wrong. Converts back the other way too, and emits ISO 8601, RFC 2822 and Discord markup.
Free · No signup · Runs entirely in your browser
Paste an epoch integer and this unix timestamp converter works out whether it is seconds, milliseconds, microseconds or nanoseconds before converting it — the unit is where these conversions actually go wrong, not the arithmetic.
Detected as seconds.
Override if the guess is wrong.
In your local time (UTC).
| Format | Value | Copy |
|---|---|---|
| ISO 8601 | 2001-09-09T01:46:40.000Z | |
| RFC 2822 | Sun, 09 Sep 2001 01:46:40 GMT | |
| Seconds | 1000000000 | |
| Milliseconds | 1000000000000 |
Discord markup
Discord renders these in each reader's own timezone and locale, so a time posted in a channel is correct for everyone. Note it takes seconds — pasting milliseconds is why a timestamp sometimes renders tens of thousands of years out.
| Style | Markup | Copy |
|---|---|---|
| Default | <t:1000000000> | |
| Short Time | <t:1000000000:t> | |
| Medium Time | <t:1000000000:T> | |
| Short Date | <t:1000000000:d> | |
| Long Date | <t:1000000000:D> | |
| Long Date, Short Time | <t:1000000000:f> | |
| Full Date, Short Time | <t:1000000000:F> | |
| Relative Time | <t:1000000000:R> |
Timezone bugs are specification bugs that reached production. Connect GitHub and Tekk turns what you want into specs your coding agent can actually execute against the real repo.
What the number means
A Unix timestamp is the count of time units since 1 January 1970, 00:00:00 UTC. It carries no timezone and no daylight saving, which is the whole point: one integer describes one instant, identically, everywhere.
The landmark worth remembering is 1000000000 — the billionth second, which fell on 9 September 2001 at 01:46:40 UTC.
The unit is where it goes wrong
The arithmetic is a division. The mistake is the unit, and it is silent:
| Digits | Unit | 1000000000... reads as |
|---|---|---|
| 10 | seconds | 9 Sep 2001 |
| 13 | milliseconds | 9 Sep 2001 |
| 16 | microseconds | 9 Sep 2001 |
| 19 | nanoseconds | 9 Sep 2001 |
Each row above has three more zeros than the one before and describes the same instant. Get the pairing wrong and the error is enormous:
- Milliseconds read as seconds → roughly 31,000 years in the future.
- Seconds read as milliseconds → 12 January 1970.
Neither looks like a rounding error, but plenty of code ships with one because the conversion happened somewhere nothing printed the result.
Which language gives you which
| Source | Unit |
|---|---|
JavaScript Date.now() |
milliseconds |
Go time.Now().Unix() |
seconds |
Python int(time.time()) |
seconds |
PHP time() |
seconds |
Java System.currentTimeMillis() |
milliseconds |
Postgres extract(epoch from now()) |
seconds (fractional) |
JavaScript and Java are the outliers, and they are also the two most likely to be on either end of an API call. Divide by 1000 before handing a JavaScript timestamp to anything expecting the Unix convention.
Discord markup
Discord accepts a timestamp in a message and renders it in each reader's own timezone:
<t:1000000000:F> → Sunday, 9 September 2001 at 01:46
<t:1000000000:R> → 25 years ago
The style character after the colon selects the format — t and T for times, d and D for dates, f and F for both, R for a relative string. Omit it for the default.
It takes seconds. Pasting a JavaScript millisecond value is why a scheduled-event announcement occasionally claims to be tens of thousands of years away.
Two things that are not what people expect
Negative timestamps are valid. Anything before 1970 is a negative integer; −86400 is 31 December 1969. Some libraries reject them, which is worth knowing before you store a historical date as an epoch value.
Leap seconds do not exist here. Unix time treats every day as exactly 86,400 seconds, so the 27 leap seconds added since 1972 are absorbed rather than counted. An epoch value is therefore not a true count of elapsed SI seconds — a distinction that matters for astronomy and almost nothing else.
How it works
- 1
Paste the number
Straight out of a log line, a JSON response or a database column. Separators and whitespace are stripped, so a value copied out of code with underscores or commas works unchanged. The current timestamp sits at the top of the tool and loads in with one click.
- 2
Check the detected unit
A ten-digit number is seconds, thirteen is milliseconds, sixteen is microseconds, nineteen is nanoseconds. This unix timestamp converter picks one by magnitude and says which it chose, so a wrong guess is visible instead of silently producing 1970 or the year 33000. Override it if you know better.
- 3
Take the format you need
UTC and your local time are shown side by side with the zone named, plus ISO 8601, RFC 2822, seconds and milliseconds — each with a copy button. The Discord section emits the <t:...> markup that renders in every reader's own timezone.
Frequently asked questions
- What is a Unix timestamp?
- A count of seconds since 1 January 1970 at 00:00:00 UTC, known as the Unix epoch. It has no timezone and no daylight saving — it is a single number describing one instant everywhere on earth, which is exactly why systems store time that way and display it later.
- How do I use a Unix timestamp converter to get a date?
- Paste it into the box above. The date appears in UTC and in your own timezone at the same time, along with how long ago or how far ahead it is. Any epoch converter does the arithmetic; the part worth checking is whether it read your number as the unit you meant.
- Why did my timestamp convert to 1970 or the year 50,000?
- Because the unit was wrong. Milliseconds read as seconds lands roughly 31,000 years in the future; seconds read as milliseconds lands a few days after 1970. This is the single most common failure with any epoch converter, and it is why the detected unit is stated on screen here rather than assumed quietly.
- Is Date.now() seconds or milliseconds?
- Milliseconds — JavaScript is the main outlier. Go's time.Now().Unix(), Python's int(time.time()), PHP's time() and most SQL engines give seconds. Divide a JavaScript timestamp by 1000 before sending it anywhere that expects the Unix convention, including Discord.
- How do I use a discord timestamp converter?
- Use the markup in the Discord section above: <t:1000000000:F> and similar. Discord renders it in each reader's own timezone and locale, so one message reads correctly for a whole server. It takes seconds — pasting milliseconds is why a discord timestamp converter result sometimes shows a date tens of thousands of years out.
- What do the Discord timestamp styles mean?
- The letter after the colon picks the format: t is a short time, T adds seconds, d is a short date, D a long one, f combines a long date with a short time, F adds the weekday, and R renders a relative time like "4 years ago". Omitting the style gives the default. Any discord timestamp converter should emit all of them, since which one you want depends entirely on the message.
- What is the difference between epoch time and ISO 8601?
- Epoch time is an integer and unambiguous but unreadable; ISO 8601 is a string like 2001-09-09T01:46:40Z that a human can read and that carries an explicit offset. Store the integer, log the string, and never do arithmetic on the string.
- Can a Unix timestamp be negative?
- Yes. Negative values are instants before 1970 — −86400 is 31 December 1969. Some libraries and databases reject them, which is a common source of trouble for anything storing historical dates, but the representation itself is perfectly well defined and this tool handles it.
- What is the year 2038 problem?
- A signed 32-bit integer runs out of room at 03:14:07 UTC on 19 January 2038, at which point systems still storing time that way wrap around to 1901. Anything using a 64-bit integer — which is most modern software — is unaffected for a period longer than the age of the universe. The unix timestamp converter above uses 64-bit arithmetic, so it handles dates either side of that boundary without complaint.
- Does this handle timezones?
- It shows the instant in UTC and in your browser's timezone, named explicitly so there is no ambiguity about which offset was applied. The timestamp itself has no timezone; the conversion to a wall-clock time is where one is chosen, and a unix timestamp converter that hides which zone it used is worse than useless.
- What about leap seconds?
- Unix time ignores them. It counts every day as exactly 86,400 seconds, so leap seconds are absorbed rather than represented, and the epoch value is not a true count of elapsed SI seconds. It almost never matters, and when it does you need TAI rather than a different converter.
- Do you store what I paste?
- No. The conversion runs entirely in your browser. Nothing is sent to a server, nothing is logged, and there is no account. Disconnect from the internet and it will still work.
- Why is this free, and what is Tekk?
- Tekk is a spec-driven development platform for people building software with AI coding agents. This tool costs us nothing to run, and the developers reading an epoch integer out of a log are the people we build for. No signup, no run limit, no upsell inside the tool.
Want a real spec for what you’re building?
Drop a sentence. Tekk grounds it in your actual code and turns it into an executable plan.
Free to try · Connect GitHub during signup