Timestamp converter
Convert Unix seconds and milliseconds into readable GMT and local dates, then turn human-friendly dates back into Unix values.
About this tool
A Unix timestamp is the number of seconds — or milliseconds — that have elapsed since the Unix Epoch: midnight on January 1, 1970, Coordinated Universal Time (UTC). It is the most common way to represent a point in time across programming languages, databases, APIs, and operating systems because it is a single timezone-independent integer that never changes regardless of locale or daylight saving rules. Understanding Unix timestamps is essential for backend development. Server logs record events in Unix time. REST APIs return created_at, updated_at, and expires_at fields as timestamps. JWT tokens store iat (issued at) and exp (expiry) as Unix seconds. Database records use integers for timestamp columns to enable fast range queries. Scheduled jobs and cron-style tasks use Unix time arithmetic to calculate next-run intervals. This tool converts Unix timestamps in both seconds and milliseconds to human-readable dates. It also converts date and time strings back to Unix values. Results are displayed in UTC, ISO 8601 format, and your browser's local timezone simultaneously for easy comparison.
- 1
Enter a Unix timestamp (seconds or milliseconds) to convert it to a human-readable date and time.
- 2
Or enter a date and time to get the corresponding Unix timestamp.
- 3
The result shows UTC and your local time zone side by side.
- 4
Click Copy to copy the timestamp or formatted date.
Check log timestamps in seconds or milliseconds and convert them into readable GMT dates.
Turn release or event dates into Unix values for APIs, databases, or scheduled jobs.
Compare Unix seconds, milliseconds, ISO strings, and local date output in one place.
Timestamp to date
17000000002023-11-14 22:13:20 UTCMillisecond timestamp to date
17000000000002023-11-14 22:13:20 UTCDate to timestamp
2024-01-15 00:00:00 UTC1705276800Timestamp converts to a date in 1970 or gives a wildly wrong year
Cause: You entered a millisecond timestamp (13 digits) but the tool interpreted it as seconds, or vice versa. 1700000000 (seconds) is 2023, but 1700000000 as milliseconds is only January 1970.
Fix: Check the digit count. A 10-digit value is Unix seconds; a 13-digit value is Unix milliseconds. The tool auto-detects both, so paste the full value without dividing or multiplying.
Converted date is off by several hours from the expected time
Cause: The conversion is correct in UTC, but the displayed local time reflects your browser's timezone offset, not the server's timezone.
Fix: Use the UTC or ISO output to get the timezone-independent value. If you need a specific timezone, note the UTC offset your server uses and adjust accordingly.
Negative timestamp or date before 1970 not accepted
Cause: Some implementations reject negative Unix timestamps even though they are valid. Dates before January 1, 1970 are represented as negative integers.
Fix: Enter the negative value directly (e.g. -86400 for December 31, 1969 23:00:00 UTC). This tool accepts negative timestamps.
These answers explain common epoch/unix converter tasks, expected input formats, and edge cases so both visitors and search engines can understand what this tool does.
What is the difference between Unix seconds and Unix milliseconds?
Unix seconds count whole seconds since January 1, 1970, while Unix milliseconds count thousandths of a second from the same point in time. Many APIs use one or the other depending on precision needs.
How do I know whether a timestamp is in seconds or milliseconds?
A 10-digit value is usually Unix seconds and a 13-digit value is usually Unix milliseconds. This tool accepts both and converts them into readable output.
Why does the date to timestamp converter ask for a timezone?
The same local date and time can represent different moments depending on timezone. Choosing GMT or your local timezone makes the conversion explicit and prevents ambiguous results.
Can I compare GMT output with my local time?
Yes. The timestamp output includes ISO output, GMT output, local output, and Unix values so you can compare the same instant in multiple representations.
JavaScript's Date object works in milliseconds. Divide by 1000 for Unix seconds. Use Intl.DateTimeFormat or date-fns for formatting.
// Current timestamp
const nowMs = Date.now(); // milliseconds since epoch
const nowSec = Math.floor(Date.now() / 1000); // seconds since epoch
// Timestamp → Date object
const date = new Date(1700000000 * 1000); // multiply seconds by 1000
console.log(date.toISOString()); // 2023-11-14T22:13:20.000Z
console.log(date.toLocaleString("en-IN", { timeZone: "Asia/Kolkata" }));
// Date string → timestamp
const ts = new Date("2023-11-14T22:13:20Z").getTime() / 1000;
console.log(ts); // 1700000000
// Format a timestamp (Intl API — no library needed)
const fmt = new Intl.DateTimeFormat("en-US", {
dateStyle: "full",
timeStyle: "long",
timeZone: "America/New_York",
});
console.log(fmt.format(new Date(1700000000 * 1000)));