Unix Timestamp Converter
Convert between Unix timestamps (epoch seconds or milliseconds) and human-readable dates. Supports multiple timezones, an instant "now" fill, and relative time display for developers.
Unix Timestamp Basics
A Unix timestamp represents a date and time as the number of seconds elapsed since 00:00:00 UTC on January 1, 1970 (the Unix epoch). Below is a table of well-known timestamp values and the dates they represent.
| Timestamp (seconds) | UTC date & time | Note |
|---|---|---|
| 0 | 1970-01-01T00:00:00Z | The Unix epoch (the starting point of all timestamps) |
| 1000000000 | 2001-09-09T01:46:40Z | The moment the timestamp reached one billion seconds (the "Unix billennium") |
| 1234567890 | 2009-02-13T23:31:30Z | A value that became a minor curiosity for containing the digits 1 through 9 in sequence |
| 2147483647 | 2038-01-19T03:14:07Z | The Year 2038 problem: the maximum value of a signed 32-bit integer (it overflows one second later) |
What This Unix Timestamp Converter Does
This tool converts freely between a Unix timestamp and a human-readable date and time. Paste a numeric timestamp and it will show you the corresponding date; enter a date and time instead, and it will calculate the matching timestamp. Both directions run entirely in your browser, so nothing you type is ever sent to a server, which makes it safe to use even with production log data or customer records.
Because the tool understands both epoch seconds and epoch milliseconds, and can display the result across six commonly used timezones at once, it is built for the everyday work of reading logs, inspecting API payloads, and comparing meeting times across a distributed team. It also handles the practical edge cases that trip up hand-written scripts, such as daylight saving transitions and rejecting calendar dates that don't actually exist.
How to Convert a Timestamp or Date
- Choose a direction Decide whether you are converting a timestamp into a date, or a date into a timestamp, and use the matching card on the page.
- Enter or paste a value For timestamp -> date, paste the numeric value you have (from a log line, database column, or API response). For date -> timestamp, pick the date and time using the picker.
- Set the unit or timezone When converting from a timestamp, leave the unit on "Auto-detect" unless you already know it is seconds or milliseconds. When converting from a date, explicitly choose which timezone that date and time belongs to.
- Read the results The converted value appears immediately: ISO 8601 (UTC), relative time, seconds, milliseconds, or the six-timezone table, depending on which direction you used.
- Use "Fill current time" when needed If you just need the timestamp for right now, click the "Fill current time" button instead of typing anything.
Tips for getting more out of it
- A 10-digit value is usually in seconds, while a 13-digit value is usually in milliseconds. Selecting "Auto-detect" infers the unit from the digit count for you.
- Paste a timestamp straight from a server log or API response to check its equivalent time across several timezones at once.
- When converting a date to a timestamp, make sure you explicitly select which timezone the entered date and time belongs to.
- The ISO 8601 (UTC) format can be parsed directly by most programming languages and databases, making it a handy reference when searching logs or designing an API.
- Click "Fill current time" to instantly populate the field with the current time from the browser's Date.now().
Common Situations Where This Helps
Reading server and application logs
Log lines often record events as raw epoch seconds or milliseconds. Paste the value here to see exactly when an error or request occurred, in your own timezone or in UTC.
Developing and debugging APIs
Many APIs accept or return timestamps as numbers rather than formatted strings. Converting a request or response value here confirms whether the API is behaving as expected before you write a single line of code.
Inspecting database timestamp columns
Databases frequently store `created_at` or `updated_at` as an integer. Rather than writing a throwaway query with a date function, you can paste the raw value here to check it in seconds.
Coordinating across timezones
When scheduling a release, deployment window, or meeting with teammates in other countries, the six-timezone table shows the same instant in UTC, Tokyo, New York, Los Angeles, London, and Paris side by side.
Generating sample data and test fixtures
When you need a realistic-looking timestamp for a test case, seed script, or example payload, entering a specific date and time here gives you a ready-to-use numeric value in either seconds or milliseconds.
Glossary
- Unix timestamp (epoch seconds)
- A single integer representing the number of seconds that have elapsed since the Unix epoch. It identifies one exact instant in time without reference to any particular timezone.
- Unix epoch
- The reference starting point for Unix timestamps: 00:00:00 UTC on January 1, 1970. All timestamps are measured as an offset, positive or negative, from this moment.
- UTC (Coordinated Universal Time)
- The global time standard that timezones around the world are defined as an offset from. Unix timestamps are always based on UTC internally, regardless of which timezone they are eventually displayed in.
- Epoch milliseconds
- A variant of the Unix timestamp scaled up by a factor of 1,000 so that it counts milliseconds instead of whole seconds. JavaScript's Date.now() and many web APIs use this unit, which is why a modern timestamp typically has 13 digits rather than 10.
- ISO 8601
- An international standard for writing dates and times as text, such as "2026-09-20T04:15:30Z". Unlike a raw timestamp, it is human-readable while still being unambiguous and easy for software to parse.
- Year 2038 problem
- A known limitation in systems that store timestamps as a signed 32-bit integer. At 03:14:07 UTC on January 19, 2038, the value reaches its maximum of 2,147,483,647 and overflows on the next second, causing the date to be misread as being back in 1901.
- DST (Daylight Saving Time)
- The practice, observed in some countries and regions, of shifting clocks forward by one hour during part of the year. It affects the date -> timestamp direction of conversion, since the same clock time can correspond to two different UTC instants around a DST transition.
- Relative time
- A way of expressing a moment relative to now, such as "3 hours ago" or "in 2 days", rather than as an absolute date. It is often easier for people to grasp at a glance than a raw timestamp or ISO string.
Frequently Asked Questions
Side Note — Why do computers count time in seconds?
Humans express dates and times as a combination of year, month, day, and time of day, such as "July 12, 2026, 5:08 PM." For a computer, however, this format is inconvenient: it has to account for complex rules like leap years, timezones, and daylight saving time, and even computing the gap between two dates becomes a cumbersome operation. The solution devised was to represent time as a single number: the number of seconds elapsed since some reference moment. This is exactly what a Unix timestamp does.
The biggest advantage of representing time as a single integer is that comparing and computing differences between dates reduces to simple arithmetic. Finding "how many seconds apart are these two events" is just a matter of subtracting one timestamp from another, with no need to worry about leap years or varying month lengths. Thanks to this simplicity, the format was adopted not only by Unix-like systems but also by Windows, databases, and the internal representations of many programming languages, making it a de facto global standard.
On the other hand, this design of a single, timezone-independent number means that timezone conversion only becomes necessary once a human needs to read the value. The very same timestamp can look like the middle of the night in Tokyo and the previous afternoon in New York, depending on which timezone it is displayed in. Many of the confusing "the time is off" bugs encountered while investigating logs or debugging API integrations trace back to exactly this kind of overlooked timezone conversion.