Date & Time

Unix Timestamp Converter

Translate Unix epoch values into readable UTC dates and convert calendar date-times back to Unix seconds. Use the dedicated epoch timeline to verify direction, magnitude, unit context, and round-trip consistency before moving timestamps between systems.

Unix timestamp (seconds) Local date and time

Timestamp to UTC date-

Date to timestamp-

Decision view

Unix epoch conversion timeline

The epoch, entered offset, and decoded UTC instant are kept together with the source unit.

Unix epochJan 1, 1970 · 00:00 UTC

Entered offset0 seconds

Decoded UTC instant-

Unix time conversion ledger Current inputs, formula path, and live output

Conversion	Source value	Formula path	Converted output
Timestamp to UTC dateUTC display of entered instant	—	Unix epoch + seconds	—
Local date to timestampWhole Unix seconds	—	Milliseconds since epoch ÷ 1000	—

How to use Unix Timestamp Converter

Enter a Unix value to decode it, or choose a calendar date and time to create a Unix timestamp.
Confirm whether the source system uses seconds or milliseconds; a three-digit unit mismatch shifts the displayed date far outside the expected year.
Read the UTC instant as the portable value. Treat any local clock rendering as a display choice rather than information stored in the timestamp.
Copy or export the result together with its unit and timezone context so another system can reproduce the conversion.

Calculator guide

Understanding Unix Timestamp Converter

A Unix timestamp represents an instant as elapsed time since 1970-01-01 00:00:00 UTC. Converting it to a readable date requires the correct unit and an explicit timezone for display.

Epoch The UTC reference instant from which Unix time is counted.

Seconds The traditional Unix timestamp unit used by many APIs and databases.

Milliseconds A common JavaScript unit that is one thousand times the seconds value.

UTC The time standard used to identify the instant independently of local timezone.

Calculation method

How the calculation works

Unix Timestamp Converter calculation Interpret the entered number in the selected unit, convert it to milliseconds when required, and construct the corresponding UTC instant. A date converted back to Unix time is measured from the UTC epoch.

Unit diagnosis

Recognizing seconds and milliseconds

Modern Unix timestamps are commonly exchanged in two magnitudes. The unit must be known before the number can identify the intended instant.

10-digit seconds Values near the present era are usually about 1.7 billion when counted in whole seconds.

13-digit milliseconds JavaScript dates and many web logs commonly use values about one thousand times larger.

Negative values A negative timestamp identifies an instant before the Unix epoch when the receiving system supports it.

Round-trip check Convert the value to a readable UTC date and back again; the original integer should be recovered at the same precision.

Never remove or add three zeroes merely because the displayed year looks wrong; confirm the source system's documented unit.

Operational example

Debugging an API event time

Suppose an API record contains 1780000000. Interpreting it as seconds produces a plausible date, while interpreting it as milliseconds points close to January 1970.

Inspect the field contract Look for names such as created_at_seconds, epoch_ms, or an explicit schema definition.

Compare adjacent records Ordering and expected event spacing can reveal an incorrect unit or truncation.

Preserve UTC Use the UTC instant for storage and apply the user's timezone only at presentation time.

Worked situations

Practical examples

Decode a 10-digit API timestamp and confirm the resulting UTC instant.
Convert an ISO-style event date into Unix seconds for a database query.
Diagnose a seconds-versus-milliseconds mismatch by comparing the expected year.

Better inputs

Useful tips

Check the number of digits: current timestamps are typically 10 digits in seconds and 13 in milliseconds.
Store timestamps with a documented unit rather than relying on digit detection alone.
Use ISO 8601 with a Z suffix when exchanging human-readable UTC dates.

Before relying on the result

Limitations and common mistakes

A timestamp alone does not preserve the original local timezone or daylight-saving rule.
Systems with 32-bit signed Unix time can encounter the Year 2038 limitation.
Leap-second handling can vary across platforms and time libraries.

Reference

Key terms

Epoch: 1970-01-01 00:00:00 UTC, the origin of Unix time.
UTC: The global time standard used to identify an instant.
ISO 8601: A standardized readable date and time format.
Timezone: A regional rule for converting UTC into local clock time.

Important note

Calculated directly from the entered values using the displayed formula and rounding settings.

Frequently asked questions

Is a Unix timestamp in seconds or milliseconds?

Traditional Unix time uses seconds, while JavaScript commonly uses milliseconds. Confirm the unit before conversion.

Does a Unix timestamp contain a timezone?

No. It identifies a UTC instant; timezone is applied only when formatting that instant for display.

What is the Unix epoch?

It is 1970-01-01 00:00:00 UTC, the reference point from which Unix time is measured.

What is the Year 2038 problem?

Some older systems store Unix seconds in a 32-bit signed integer, which overflows in January 2038.