Quick Answer
A Unix timestamp is the number of seconds since 00:00:00 UTC on 1 January 1970. The timestamp 1,700,000,000 is 2023-11-14 22:13:20 UTC, a Tuesday. To convert, divide the seconds into days, hours, minutes and seconds from that starting point.
Embed this calculator
Adjust the size if needed, then copy the code below into your page or blog. The calculator will load in an iframe and stay updated automatically.
Table of Contents
- Unix Timestamp Converter
- Quick Answer
- Related Calculators
- How This Unix Timestamp Converter Works
- How to Use the Unix Timestamp Converter
- Core Formulas
- Key Terms
- Worked Example
- Real-Life Examples
- Unix Time vs ISO 8601
- Notable Unix Timestamps
- Tips
- Getting Unix Time in Code
- Common Mistakes to Avoid
- Frequently Asked Questions
- References & Sources
How This Unix Timestamp Converter Works
Choose timestamp to date, and enter a Unix timestamp in seconds or milliseconds. The converter shows the date and time in UTC, in your own time zone and in ISO 8601 format, plus the weekday and how long ago or how far ahead it is. Choose date to timestamp to go the other way: enter a date and time, pick UTC or your local zone, and get the timestamp in seconds and milliseconds.
Quick explanation: computers often store time as one big number.
- Epoch: 1 January 1970 at 00:00:00 UTC is timestamp 0.
- Seconds: most Unix timestamps have 10 digits today.
- Milliseconds: JavaScript and many APIs use 13 digits.
How to Use the Unix Timestamp Converter
- Choose timestamp to date or date to timestamp.
- Enter the timestamp, or the date and time.
- For a date, choose UTC or your local time zone.
- Press Calculate.
- Read the timestamp, UTC and local times and ISO 8601 format.
Core Formulas
- Timestamp: seconds since 1970-01-01 00:00:00 UTC
- Milliseconds: seconds × 1,000
- Days since the epoch: timestamp ÷ 86,400
- One day: 86,400 seconds. One week: 604,800 seconds
- Local time: UTC + your time zone offset
Key Terms
- Unix time: the number of seconds since 1 January 1970 00:00:00 UTC.
- Epoch: the starting point of a time system, here 1 January 1970 UTC.
- UTC: Coordinated Universal Time, the world’s reference time.
- ISO 8601: an international standard for writing dates and times.
- Year 2038 problem: the overflow of 32-bit signed Unix time on 19 January 2038.
Worked Example
Convert 1,700,000,000 to a date.
- 1,700,000,000 ÷ 86,400 = 19,675 whole days, with 80,000 seconds left over
- 80,000 seconds = 22 hours, 13 minutes and 20 seconds
- 19,675 days after 1 January 1970 is 14 November 2023, so the time is 22:13:20 UTC
Real-Life Examples
- Reading logs: turn timestamps in server logs into readable times.
- APIs and databases: check values stored as epoch seconds or milliseconds.
- Scheduling: find the timestamp for a future date to set an expiry.
- The 2038 problem: 32-bit signed time ends at 2,147,483,647, which is 2038-01-19 03:14:07 UTC.
Unix Time vs ISO 8601
- Unix time: one number, easy for computers to store and compare.
- ISO 8601: readable text like 2024-01-01T00:00:00Z, with Z meaning UTC.
- Both: describe the same moment, so you can convert either way.
Notable Unix Timestamps
| Timestamp | Date and time (UTC) |
|---|---|
| 0 | 1970-01-01 00:00:00 |
| 86,400 | 1970-01-02 00:00:00 |
| 946,684,800 | 2000-01-01 00:00:00 |
| 1,000,000,000 | 2001-09-09 01:46:40 |
| 1,234,567,890 | 2009-02-13 23:31:30 |
| 1,500,000,000 | 2017-07-14 02:40:00 |
| 1,700,000,000 | 2023-11-14 22:13:20 |
| 2,000,000,000 | 2033-05-18 03:33:20 |
| 2,147,483,647 | 2038-01-19 03:14:07 |
Tips
- Check the digits: 10 digits is usually seconds, 13 digits milliseconds.
- Store in UTC: convert to local time only when showing it to people.
- Negative timestamps: are dates before 1970.
- Daylight saving time: local times shift, but the timestamp does not.
Getting Unix Time in Code
Most programming languages have a built-in way to read the current Unix time or convert a timestamp to a date.
- JavaScript:
Math.floor(Date.now() / 1000)gives seconds, andnew Date(ts * 1000)turns seconds back into a date. - Python:
int(time.time())gives seconds, anddatetime.fromtimestamp(ts, timezone.utc)gives a UTC date. - PHP:
time()gives seconds, anddate('Y-m-d H:i:s', ts)formats it. - Linux shell:
date +%sprints the current timestamp.
Remember that JavaScript works in milliseconds, while most other languages and databases work in seconds. Mixing the two is the most common cause of dates that land in 1970 or far in the future.
Common Mistakes to Avoid
- Mixing seconds and milliseconds. A 13-digit number read as seconds is thousands of years ahead.
- Forgetting the time zone. The same timestamp shows different local times around the world.
- Storing local time. Use UTC in databases to avoid daylight saving problems.
- Assuming leap seconds count. Unix time skips them.
- Using 32-bit time. It overflows in January 2038.
Frequently Asked Questions
The number of seconds since 00:00:00 UTC on 1 January 1970, not counting leap seconds.
Enter it in the converter. It shows the date in UTC and your local time.
Usually 10 digits means seconds and 13 digits means milliseconds. The converter detects this.
Choose date to timestamp and enter the current date and time, or check the relative time shown.
Another name for Unix time.
None. It counts from a fixed moment in UTC, so it is the same everywhere.
Yes. Negative values are dates before 1970.
Systems that store time in a signed 32-bit number overflow after 2,147,483,647 seconds, on 19 January 2038.
No. Each day is counted as exactly 86,400 seconds.
86,400.
Zulu time, which means UTC.
It is a single number that is easy to store, sort and compare.
References & Sources
| Source | Used For | Link |
|---|---|---|
| Wikipedia, Unix time | Definition, the epoch, leap seconds and the 2038 problem. | https://en.wikipedia.org/wiki/Unix_time |
| The Open Group, POSIX Base Definitions, Seconds Since the Epoch | The POSIX definition of Unix time. | https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap04.html |