Unix Timestamp Converter
Convert between Unix timestamps and human dates.
Seconds since 1970-01-01 UTC, updating every second. Computed in your browser.
Timestamp to date
Whole seconds, or milliseconds (a 13-digit value auto-detects as ms).
UTC (ISO 8601)
- Local time
- 15/11/2023, 3:43:20 am
- Seconds
- 1700000000
- Milliseconds
- 1700000000000
- Read as
- Seconds
Local time uses your device's timezone. The ISO string is always UTC.
Date to timestamp
Accepts dates, times, and offsets, e.g. 2023-11-14, 2023-11-14T22:13:20Z, +05:30.
Unix seconds
- Milliseconds
- 1700000000000
- UTC (ISO 8601)
- 2023-11-14T22:13:20.000Z
Add an offset (Z or +05:30) for an exact instant. A bare date or offset-less time is read in your local timezone.
How the Unix timestamp converter works
This tool moves between two ways of naming an instant: a Unix timestamp, which is a plain integer counting seconds from 1 January 1970 UTC, and a human calendar date in ISO 8601 form. It converts in both directions and shows the live current timestamp so you always have a reference point.
Going from a timestamp to a date, the tool reads your integer, decides whether it is seconds or milliseconds, and produces two strings: the absolute time in UTC and the same instant in your local timezone. Going the other way, it parses an ISO date-time and reports the matching timestamp in both seconds and milliseconds. All the work happens in your browser, on your device’s clock.
The reason a single integer is enough to pin down a moment is that the count is anchored to one fixed origin and one fixed unit. There is no timezone baked into the number, no calendar quirks, and no ambiguity about formatting. That makes timestamps ideal for sorting events, measuring how long something took, or comparing two records, because the comparison is plain integer arithmetic. The calendar string is only ever a human-friendly view layered on top of that count.
Worked example
Take the timestamp 1700000000. It has ten digits, so it reads as seconds. Counting that many seconds from the 1970 epoch lands on:
| Output | Value |
|---|---|
| UTC (ISO 8601) | 2023-11-14T22:13:20.000Z |
| Seconds | 1700000000 |
| Milliseconds | 1700000000000 |
Now go the other way. Type the date 2023-11-14T22:13:20Z, where the trailing Z means UTC. The converter returns 1700000000 seconds, closing the loop exactly. Enter the very same instant for a timezone five and a half hours ahead, 2023-11-15T03:43:20+05:30, and you get the identical 1700000000, because the offset is folded into the result.
How to use it
- To decode a timestamp, paste it into the Unix timestamp field. Leave the unit on auto, or set it to seconds or milliseconds if you know which you have.
- A 13-digit value is treated as milliseconds; a shorter value as seconds. The result panel tells you which reading was used.
- To encode a date, type an ISO 8601 string into the date field. A bare date such as
2023-11-14or a time without an offset is read in your local timezone; addZor an offset like+05:30for an exact instant. - Use the current Unix time readout at the top to grab a fresh timestamp or to sanity-check a value against right now.
Limitations
This is a conversion aid, not a calendar engine. It does not apply leap seconds, which the Unix clock ignores by design, and it does not convert between arbitrary named timezones beyond your own local zone and UTC. Very large values are rejected once they fall outside the range a standard date can represent. For scheduling, billing, or legal deadlines, confirm the instant against the system that owns the data, since rounding and timezone assumptions can differ between platforms.
Frequently asked questions
What is a Unix timestamp?
A Unix timestamp is the number of seconds that have passed since midnight UTC on 1 January 1970, a moment known as the Unix epoch. It is a single integer that names an exact instant in time, independent of any timezone or calendar format. Because it is just a count of seconds, it is easy to store, sort, and do arithmetic on, which is why logs, databases, and APIs lean on it so heavily.
How do I tell seconds from milliseconds?
Both are counts from the same 1970 epoch, but milliseconds are a thousand times larger. A practical rule is digit length: a seconds timestamp for any date in the next few centuries has 10 to 12 digits, while a milliseconds value has 13 or more. This converter auto-detects on that boundary, treating a 13-digit number as milliseconds, and you can override the unit explicitly when you already know which one you have.
Why does the local time differ from the UTC time?
The same instant is shown two ways. The UTC line is the absolute time at the zero meridian and never changes. The local line shifts that instant into your device's timezone, applying any offset and daylight-saving rule in effect. Two people in different timezones reading the same timestamp see the same UTC string but different local strings, and both are correct.
Can it handle dates before 1970?
Yes. Timestamps before the epoch are simply negative. For example -100000 seconds is 30 December 1969. The converter accepts negative values and parses pre-1970 ISO dates without trouble, so it works for historical instants as well as future ones.
Does my data leave the browser?
No. Every conversion runs entirely on your device using its own clock and date functions. Nothing you type is sent over the network, logged, or stored on a server, so the timestamps and dates you enter stay private to your browser.