Toolsky

Free Online Tools & Utilities for Every Task.

Timestamp Converter

Convert to & from UNIX Timestamps.

Human Readable Time Seconds
1 minute 60 seconds
1 hour 3600 seconds
1 day 86400 seconds
1 week 604800 seconds
1 month 2629743 seconds
1 year 31556926 seconds





Buried in almost every database row, log file and API response is a plain ten-digit number that quietly records the exact moment something happened. That number is a Unix timestamp, and while it is perfect for computers, it means nothing to a human skimming a record at midnight. The Timestamp Converter on ToolSky translates both ways: turn a timestamp into a readable date and time, or turn a date and time back into the numeric form your code, database or spreadsheet expects.

What a Unix Timestamp Actually Counts

A Unix timestamp is simply the number of seconds that have elapsed since 00:00:00 UTC on 1 January 1970, a moment known as the Unix epoch. Every second since then adds one to the count, so any instant can be stored as a single integer with no months, no time zone names and no formatting arguments. That simplicity is why timestamps turn up everywhere: web servers stamp log entries with them, apps store account creation dates as them, and APIs return them because every programming language can convert them the same way.

The catch is that the number alone tells you nothing at a glance. A value like 1700000000 could be last week or next year for all your eyes know, and a misplaced digit or a milliseconds value pasted where seconds belong produces dates in the year 56000 or back in 1970. A converter removes the guesswork and the mental arithmetic in one step.

What This Timestamp Converter Does

  • Converts a Unix timestamp in seconds into a full human-readable date and time.
  • Converts a date and time you enter back into its Unix timestamp equivalent.
  • Lets you move between the machine format used by software and the calendar format people actually read, without installing anything or writing throwaway code.

Because it works in both directions, the same page serves two different jobs: decoding values you have found in data, and producing values you need to paste into a query, a config file or a test payload. If you are working with durations rather than fixed moments, the Time Duration Calculator handles the gaps between two dates, and the World Clock helps when the people reading your converted time sit in other time zones.

How to Use the Timestamp Converter

  1. Copy the timestamp from your log, database or API response, or note the date and time you want to convert.
  2. Paste the timestamp into the input field if you are converting to a date, or enter the date and time if you are converting the other way.
  3. Run the conversion and read the result.
  4. Check whether the result is shown in UTC or converted to your local time, and note which one your task needs.
  5. Sanity-check the output against a known reference point, such as a file's modified date, before relying on it.
  6. Copy the converted value into your report, query or code.

A Worked Example: Reading 1700000000

Take the timestamp 1700000000. Counting that many seconds forward from the epoch lands on Tuesday 14 November 2023 at 22:13:20 UTC. If you were in a time zone five hours ahead of UTC, the same instant would read 03:13:20 on 15 November locally, which is why two people can convert the same number and both be right while seeing different clocks. Going the other way, midnight at the start of 1 January 2024 UTC corresponds to the timestamp 1704067200, a handy anchor when you are testing date filters around the new year.

The roundness of 1700000000 also shows why timestamps are sequenced so reliably: sort a column of them numerically and you have sorted your events chronologically, something that cannot be said for date strings written in mixed formats.

Mistakes and Mix-Ups to Watch For

The most common error is the seconds-versus-milliseconds mix-up. JavaScript's Date.now() returns milliseconds, so its values have thirteen digits, while classic Unix timestamps have ten. Paste a millisecond value into a seconds field and you get a date tens of thousands of years away; paste seconds where milliseconds are expected and everything collapses to January 1970. Count the digits before you convert.

The second trap is time zones. A timestamp itself is zone-free because it counts from a UTC anchor, but the moment you render it as a clock time, a zone has to be chosen. Server logs compared against your local notes will look shifted by exactly your UTC offset if you forget this. Finally, beware values copied from spreadsheets, which sometimes mangle long numbers into scientific notation and silently drop the last digits.

Frequently Asked Questions About Unix Timestamps

What exactly is the Unix epoch?

It is the agreed starting point of 1 January 1970 at 00:00:00 UTC. Every Unix timestamp counts the seconds elapsed since that instant.

Is a timestamp tied to a time zone?

No. The number itself is universal. Time zones only enter when the number is displayed as a date and clock time, which is why the same timestamp renders differently in different places.

How can I tell whether a value is in seconds or milliseconds?

Count the digits. Current-era timestamps in seconds have ten digits, while millisecond values have thirteen. A converted result landing in 1970 or the far future is a strong hint you picked the wrong unit.

Can timestamps be negative?

Yes. Moments before the epoch are represented by negative numbers, so a timestamp of -86400 means 31 December 1969 at 00:00:00 UTC.

What is the year 2038 problem?

Older systems store timestamps in a signed 32-bit integer, which overflows on 19 January 2038. Software using 64-bit values is unaffected, but legacy systems still need checking.

Do Unix timestamps count leap seconds?

No. Unix time treats every day as exactly 86,400 seconds and ignores the leap seconds occasionally added to civil time, which keeps arithmetic simple.

Why does my converted time differ from a colleague's by a few hours?

Almost certainly a time zone difference. Compare the UTC rendering of the timestamp first; if those match, both conversions are correct and only the display zones differ.

When Timestamps Save You Hours

Whether you are debugging a payment that posted at the wrong moment, auditing login records or seeding test data with realistic dates, converting by hand is slow and error-prone. Keep this converter open while you work and the ten-digit numbers in your data turn back into moments you can reason about.