Unix Timestamp Converter
Convert Unix timestamps to human-readable dates.
How to use Unix Timestamp Converter
Paste your Unix timestamp
Click the input field labeled 'Enter Unix Timestamp' and paste or type your 10-digit Unix timestamp (e.g., 1704067200). The field accepts timestamps in seconds or milliseconds.
Select your timezone
Click the 'Timezone' dropdown menu below the input field and choose your desired timezone from the list (UTC, EST, PST, IST, etc.). The default is UTC.
View instant conversion
The human-readable date and time appear automatically in the 'Converted Date' output box. The format displays as 'YYYY-MM-DD HH:MM:SS' by default.
Copy or convert another timestamp
Click the blue 'Copy' button next to the result to copy to clipboard, or clear the input field and enter a new Unix timestamp to convert multiple values.
Related Tools
Unix timestamp converter: epoch time to date and back
Unix timestamp converter: epoch time to date and back
Got a Unix timestamp and need to know what date and time it represents? Use the free Unix timestamp converter on ToolHQ to convert epoch timestamps to readable dates and vice versa, with the current Unix time shown live.
A Unix timestamp (also called epoch time) is a number representing the total seconds elapsed since January 1, 1970, 00:00:00 UTC. It is the standard way that computer systems, databases, APIs, and log files store and transmit time information.
For developers, data analysts, and anyone working with system logs or APIs, encountering a number like 1720000000 and needing to know what moment it represents is a regular task. ToolHQ's converter translates between timestamps and human-readable dates in both directions, supports seconds and milliseconds, and shows the current Unix timestamp live so you always have a reference point.
Key Takeaways
- Unix time = number of seconds since January 1, 1970, 00:00:00 UTC (the Unix epoch)
- 1 day = 86,400 seconds; 1 week = 604,800 seconds; 1 year = approximately 31,557,600 seconds
- A 10-digit timestamp is in seconds; a 13-digit timestamp is in milliseconds
- Conversion works both ways: timestamp to date, and date to timestamp
- No data is stored or transmitted, all conversion runs in your browser
What Unix timestamps are and how they work
A Unix timestamp counts time as a single increasing integer. That integer represents the number of seconds (or milliseconds in some systems) since the Unix epoch: midnight on January 1, 1970, in Coordinated Universal Time (UTC).
According to Wikipedia's Unix time article, this system was developed with the original Unix operating system and has become the de facto standard for representing time in software. Because it is just an integer and is always referenced to UTC, Unix timestamps are:
- Time zone neutral. A Unix timestamp represents the same moment worldwide. Converting to local time is done at display time, not storage time.
- Sortable. Because timestamps are integers, they sort correctly chronologically without special date comparison logic.
- Language agnostic. Every programming language and database handles Unix timestamps natively.
- Compact. A 10-digit integer takes less storage and bandwidth than a formatted date string.
The timestamp 1720000000, for example, corresponds to July 3, 2024, at 04:26:40 UTC. You cannot intuit that from the number alone, which is why a converter is essential.
The companion standard to Unix time is RFC 3339, which defines a human-readable date/time format (e.g., 2024-07-03T04:26:40Z) that is interoperable with ISO 8601. Many APIs return either Unix timestamps or RFC 3339 strings, and converting between them is a routine developer task.
Seconds vs. milliseconds: a common source of confusion
One of the most frequent sources of errors when working with Unix timestamps is not knowing whether a timestamp is in seconds or milliseconds.
Seconds timestamps (Unix time): 10 digits. Example: 1720000000
Milliseconds timestamps (Unix milliseconds): 13 digits. Example: 1720000000000
JavaScript's Date.now() returns milliseconds. Python's time.time() returns seconds (as a float). Many databases store in milliseconds. API responses vary by platform. Pasting a millisecond timestamp into a seconds converter gives a date far in the future (year 55,000+), which is a quick way to tell you have the wrong unit.
The rule of thumb: if your timestamp is 10 digits, it is in seconds. If it is 13 digits, it is in milliseconds. ToolHQ's converter detects and handles both automatically.
Quick reference: seconds in common time units
| Time unit | Seconds | Milliseconds |
|---|---|---|
| 1 minute | 60 | 60,000 |
| 1 hour | 3,600 | 3,600,000 |
| 1 day | 86,400 | 86,400,000 |
| 1 week | 604,800 | 604,800,000 |
| 1 month (avg.) | 2,629,743 | 2,629,743,000 |
| 1 year (avg.) | 31,557,600 | 31,557,600,000 |
When you need a Unix timestamp converter
Reading API responses. Many APIs return created_at: 1720000000 instead of a formatted date. A converter tells you immediately what that moment was.
Debugging log files. Application and server logs often timestamp events in epoch time. Converting those numbers to readable dates helps you correlate events to real-world incidents.
Database work. SQL databases frequently store datetimes as Unix timestamps. If you are writing queries or inspecting data, you need to know what those numbers represent.
Building date logic in code. If you are writing a script that checks "did this event happen in the last 7 days," knowing that 7 days = 604,800 seconds lets you write the comparison directly in epoch arithmetic.
Generating timestamps for API calls. Some APIs require you to pass an expiry time or a start date as a Unix timestamp. The converter lets you enter a human date and get the corresponding integer.
Take Priya, a backend engineer debugging a payment processing issue. Her team's logs showed a transaction with a timestamp: 1709251200. She needed to know if that was before or after a configuration change they made on March 1, 2024 at noon UTC. She pasted the number into the converter: the result was March 1, 2024 at 00:00:00 UTC. The timestamp was from midnight, not noon. That placed the transaction before the config change, which changed the direction of her investigation entirely. Five seconds with a timestamp converter, problem scoped.
How to use the ToolHQ Unix timestamp converter
The converter works in both directions.
Convert a timestamp to a date:
- Paste or type your Unix timestamp into the input field.
- The converter detects whether it is seconds or milliseconds.
- It instantly shows the equivalent date and time in UTC and your local time zone.
Convert a date to a timestamp:
- Enter a date and time using the date picker or type it in.
- Select the time zone if relevant.
- The converter shows the equivalent Unix timestamp in both seconds and milliseconds.
Current timestamp: The tool displays the current Unix time live, updating every second. This is useful as a reference point for calculations or for capturing "now" as a timestamp.
No data is stored or transmitted. All conversions run in your browser.
For related tools, the date calculator handles date arithmetic in human-readable form, and the json-formatter is useful when the timestamp appears inside a JSON API response you need to inspect.
Common Unix timestamp reference values
| Date | Unix timestamp (seconds) |
|---|---|
| January 1, 2000 00:00:00 UTC | 946,684,800 |
| January 1, 2010 00:00:00 UTC | 1,262,304,000 |
| January 1, 2020 00:00:00 UTC | 1,577,836,800 |
| January 1, 2024 00:00:00 UTC | 1,704,067,200 |
| January 1, 2025 00:00:00 UTC | 1,735,689,600 |
| January 1, 2026 00:00:00 UTC | 1,767,225,600 |
| January 1, 2030 00:00:00 UTC | 1,893,456,000 |
| January 19, 2038 03:14:07 UTC | 2,147,483,647 |
The last entry is significant: 2,147,483,647 is the maximum value a 32-bit signed integer can hold. On January 19, 2038, at 03:14:08 UTC, 32-bit systems that store Unix time as a signed 32-bit integer will overflow and roll back to 1901. Modern 64-bit systems handle Unix time without this problem, but legacy systems may need updates before 2038.
Unix time vs. ISO 8601
Both Unix timestamps and ISO 8601 strings are common ways to represent time in software. Here is when to use each:
| Format | Example | Best for |
|---|---|---|
| Unix timestamp (seconds) | 1720000000 |
Storage, math, sorting, APIs |
| Unix timestamp (ms) | 1720000000000 |
JavaScript, sub-second precision |
| ISO 8601 | 2024-07-03T04:26:40Z |
Human-readable interchange, REST APIs |
| RFC 3339 | 2024-07-03T04:26:40+00:00 |
Internet protocols, email |
Both ISO 8601 and RFC 3339 are time-zone-explicit (the Z suffix means UTC, +05:30 means IST). Unix timestamps are always UTC by definition.
Marcus was building an API integration and needed to pass a "valid_until" timestamp in the request body. The documentation said it expected Unix epoch time in seconds. He had a date in mind (August 1, 2024, midnight UTC) but needed the integer. He used the converter, entered the date, and got 1722470400. He pasted that directly into his API test, and the request worked on the first try. The json-formatter helped him inspect the full API response that came back.
Frequently asked questions
What is a Unix timestamp?
A Unix timestamp is the number of seconds elapsed since January 1, 1970, 00:00:00 UTC (the Unix epoch). It is the standard way computer systems represent moments in time as a single integer.
How do I tell if a timestamp is in seconds or milliseconds?
Count the digits. A 10-digit timestamp is in seconds. A 13-digit timestamp is in milliseconds. A seconds timestamp multiplied by 1,000 gives the milliseconds equivalent.
What does the current Unix timestamp look like?
As of mid-2024, the Unix timestamp is around 1,720,000,000 (seconds). It increases by 1 every second. You can see the live value at the top of ToolHQ's Unix timestamp converter.
Can I convert a date to a Unix timestamp?
Yes. Enter the date and time in the "date to timestamp" input, and the converter instantly shows the corresponding Unix timestamp in both seconds and milliseconds.
What is the Year 2038 problem?
32-bit systems store Unix time as a signed 32-bit integer with a maximum value of 2,147,483,647. That value corresponds to January 19, 2038, at 03:14:07 UTC. After that second, 32-bit systems overflow. 64-bit systems are not affected and can represent Unix time far into the future.
The short version
Unix timestamps are the standard currency of time in software: compact integers that are time-zone-neutral, sortable, and universally supported. ToolHQ's converter translates between timestamps and human-readable dates in both directions, handles seconds and milliseconds automatically, and shows the live current timestamp for reference.
No account needed, no data stored.
For date arithmetic in human-readable form, use the date calculator. For working with JSON API responses that contain timestamps, try the json-formatter. For time zone display, use the time zone converter.