Free epoch timestamp conversion tool
Unix Time Converter
Convert Unix timestamps in seconds or milliseconds to readable UTC dates. You can also convert a UTC date and time back to Unix seconds and milliseconds with clear precision and range checks.
Last Updated: July 25, 2026
Convert Unix Time and UTC
Select a direction, enter one value and review the normalized timestamp, ISO 8601 value, UTC date and signed 32-bit status.
A Unix time converter changes a machine-friendly timestamp into a readable UTC date and time. It also performs the reverse calculation. Enter 1784980800 seconds and the tool returns Saturday, July 25, 2026 at 12:00:00 UTC. Enter that UTC date and time and it returns the same Unix timestamp.
The calculator keeps seconds and milliseconds separate, supports timestamps before the 1970 epoch, and preserves up to millisecond precision. Every result includes an ISO 8601 value, Unix seconds, Unix milliseconds, the UTC weekday, the instant's position relative to the epoch, and a signed 32-bit range check.
How to Use the Unix Time Converter
- Select Unix timestamp to UTC date when you have a numeric epoch value.
- Enter the timestamp. Seconds may contain up to three decimal places. Milliseconds must be a whole number.
- Select seconds, milliseconds, or auto-detect. Use an explicit unit when a short value might have either meaning.
- Select UTC date to Unix timestamp when you have a calendar date and clock time.
- Enter the date, 24-hour UTC time, and optional millisecond value.
- Select the convert button. Review both timestamp units and the ISO 8601 output.
- Use Switch Direction to move the last valid result into the opposite input panel.
- Use Current Time to load the current instant from your device clock. The calculation still displays that instant in UTC.
What Is Unix Time?
Unix time is a numeric representation of an instant. Its reference point, called the Unix epoch, is January 1, 1970 at 00:00:00 UTC. Unix timestamp 0 names that instant. Positive values identify times after it. Negative values identify times before it on systems that support signed timestamps.
The current POSIX definition of seconds since the Epoch assigns exactly 86,400 timestamp seconds to each day. The POSIX gmtime specification describes conversion from seconds since the epoch to a broken-down Coordinated Universal Time value.
A Unix timestamp does not contain a printed year, month, weekday, time-zone name, or daylight-saving rule. Software derives those display values from the numeric instant. This compact structure works well for logs, APIs, databases, tokens, file metadata, event ordering, and system clocks.
Unix Timestamp Conversion Formula
The core calculation uses the Unix epoch as zero. A timestamp in seconds counts timestamp seconds from that reference instant. A millisecond timestamp uses the same reference point at one-thousandth-second resolution.
The sign matters. Adding a positive value moves forward from the epoch. Adding a negative value moves backward. A value of -1 second therefore represents December 31, 1969 at 23:59:59 UTC.
Worked Example: Convert 1784980800 to a Date
Assume the input unit is seconds. Multiply the timestamp by 1,000 to obtain the millisecond value used for precise browser date calculations.
- Entered timestamp: 1,784,980,800 seconds.
- Milliseconds: 1,784,980,800 multiplied by 1,000 = 1,784,980,800,000.
- Add that signed duration to the Unix epoch.
- UTC result: Saturday, July 25, 2026 at 12:00:00 UTC.
- ISO 8601 result:
2026-07-25T12:00:00.000Z. - The timestamp remains below 2,147,483,647, so it fits a signed 32-bit seconds field.
The final Z in the ISO value means the UTC offset is zero. RFC 3339 uses this form for unambiguous Internet timestamps. The RFC 3339 specification recommends fully qualified dates and a stated relationship to UTC.
Unix Seconds vs Unix Milliseconds
Many Unix and POSIX interfaces use seconds. JavaScript, browser storage, and numerous APIs use milliseconds. Treating one unit as the other moves the result by a factor of 1,000 and often produces a date near 1970 or far outside the intended range.
| Unit | Example for July 25, 2026 at 12:00 UTC | Precision | Common clue |
|---|---|---|---|
| Seconds | 1784980800 |
One second, or a decimal fraction when supported | Usually 10 digits for present-day positive values |
| Milliseconds | 1784980800000 |
One-thousandth of a second | Usually 13 digits for present-day positive values |
| Microseconds | 1784980800000000 |
One-millionth of a second | Often 16 digits; not accepted by this tool |
| Nanoseconds | 1784980800000000000 |
One-billionth of a second | Often 19 digits; not accepted by this tool |
This calculator supports seconds and milliseconds only. It rejects microsecond and nanosecond values instead of silently rounding a large integer that ordinary JavaScript numbers cannot always represent exactly.
Negative Unix Timestamps
A negative timestamp identifies an instant before the epoch. Timestamp -1 is one second before zero. Timestamp -1000 means either 1,000 seconds before the epoch or 1,000 milliseconds before it, depending on the selected unit. Auto-detection cannot resolve that semantic ambiguity, so choose the unit.
Some older systems and data types reject negative timestamps even though the mathematical conversion is clear. Confirm the destination platform's supported range before moving historical data between a database, programming language, spreadsheet, or API.
UTC, Local Time, and Time Zones
The same Unix timestamp identifies one instant worldwide. A local display can show different clock times for that instant because each place applies its UTC offset and any daylight-saving rule. This converter deliberately uses UTC for input and output. It does not guess your location or apply a regional time-zone database.
For example, 0 always resolves here to January 1, 1970 at 00:00:00 UTC. A system displaying that instant in a negative UTC offset might show a local calendar date of December 31, 1969. Both displays can identify the same instant.
Z or an explicit numeric offset. Convert it to a named local zone only for display or a location-specific scheduling rule.The Year 2038 Problem
A signed 32-bit integer can store values from -2,147,483,648 through 2,147,483,647. When such a field stores whole Unix seconds, the maximum maps to January 19, 2038 at 03:14:07 UTC. Adding one more second overflows that particular representation.
| Boundary | Unix seconds | UTC date and time |
|---|---|---|
| Signed 32-bit minimum | -2147483648 |
December 13, 1901 at 20:45:52 UTC |
| Unix epoch | 0 |
January 1, 1970 at 00:00:00 UTC |
| Signed 32-bit maximum | 2147483647 |
January 19, 2038 at 03:14:07 UTC |
| First second above maximum | 2147483648 |
January 19, 2038 at 03:14:08 UTC |
The 2038 boundary does not make every Unix timestamp invalid. Modern systems often use wider signed types. The result card checks only whether the selected instant fits the traditional signed 32-bit whole-second range. It does not certify a specific database column or operating system.
Leap Seconds and Unix Time
Unix or POSIX time does not provide a unique continuous count of every UTC leap second. POSIX assigns exactly 86,400 timestamp seconds to each day. The calculator therefore does not accept 23:59:60 as a calendar input and does not add accumulated leap seconds to the timestamp.
The NIST leap-second guidance explains why UTC sometimes receives an added second. The ECMAScript date specification also states that its time values do not account for UTC leap seconds. Specialized scientific or traceable timing work may require UTC, TAI, GPS, NTP, or another defined time scale with its own conversion data.
Supported Range and Precision
This browser calculator accepts instants from January 1, 1900 at 00:00:00.000 UTC through December 31, 2100 at 23:59:59.999 UTC. That focused range covers historical negative timestamps, present-day values, the Year 2038 boundary, and common planning dates while keeping input validation clear.
Seconds may contain zero to three decimal digits. A value such as 1.25 seconds becomes 1,250 milliseconds after the epoch. Millisecond inputs must be whole numbers. The converter does not accept scientific notation, commas, spaces inside the number, special numeric values, microseconds, or nanoseconds.
Common Unix Timestamp Errors
- Wrong unit: A seconds value interpreted as milliseconds appears close to 1970. A milliseconds value interpreted as seconds usually exceeds the supported range.
- Local input treated as UTC: A local clock reading needs its time-zone rule before it becomes an unambiguous instant.
- Seconds omitted from a date: A date alone defaults to a boundary such as midnight only when the receiving system defines that rule.
- Fraction silently rounded: Preserve milliseconds when event ordering or logs require sub-second precision.
- Signed range ignored: A valid modern timestamp might still overflow an older 32-bit field.
- Leap seconds counted manually: Unix timestamp conversion follows POSIX-style day mapping rather than a simple count of all SI seconds since 1970.
Unix Time, ISO 8601, and Human-Readable Dates
| Format | Example | Best use | Main caution |
|---|---|---|---|
| Unix seconds | 1784980800 |
Compact storage, sorting, APIs, logs | The unit and supported integer range must be known |
| Unix milliseconds | 1784980800000 |
Browser and application event timing | Easy to confuse with seconds |
| ISO 8601 UTC | 2026-07-25T12:00:00.000Z |
Readable data exchange with explicit UTC | A missing offset makes a date-time ambiguous |
| Readable UTC | July 25, 2026 at 12:00 UTC | Reports and user interfaces | Localized formats can sort poorly or swap month and day |
Related Date and Time Calculators
Frequently Asked Questions
What is a Unix timestamp?
A Unix timestamp is a signed numeric representation of an instant relative to January 1, 1970 at 00:00:00 UTC. Common versions count seconds or milliseconds from that epoch.
What date is Unix timestamp 0?
Unix timestamp 0 is January 1, 1970 at 00:00:00 UTC. It is the Unix epoch. Positive timestamps fall after it, while negative timestamps fall before it.
Is Unix time always UTC?
Unix time identifies an instant relative to a UTC-based epoch and does not carry a local time-zone label. Software may display that instant in UTC or convert it to a selected local zone.
How do I tell Unix seconds from milliseconds?
Present-day timestamps usually have 10 digits in seconds and 13 digits in milliseconds. Values near the epoch are shorter, so the digit count is only a clue. Select the known unit explicitly for an ambiguous value.
Can Unix timestamps be negative?
Yes. A negative timestamp represents a time before January 1, 1970 on systems that support signed values. For example, -1 second is December 31, 1969 at 23:59:59 UTC.
What is the Year 2038 problem?
A signed 32-bit seconds field reaches its maximum value of 2,147,483,647 on January 19, 2038 at 03:14:07 UTC. Older systems using that storage format may overflow on the following second.
Does Unix time include leap seconds?
POSIX-style Unix time assigns exactly 86,400 timestamp seconds to every day and does not uniquely count an inserted leap second. This converter does not accept a clock second value of 60.
Does this converter use my local time zone?
No. Calendar inputs and outputs use UTC. The Current Time button reads the current instant from your device, then displays that instant in UTC without applying a named local-zone conversion.
What date range does this Unix time converter support?
It supports UTC instants from January 1, 1900 through December 31, 2100 with millisecond precision. Values outside that focused range are rejected with a clear error.
This calculator is an informational conversion tool. Confirm timestamp units, precision, time scale, time-zone rules, storage width, platform limits, and leap-second behavior before using a result for security, legal, financial, scientific, medical, aviation, database-migration, or production-system decisions.