All the calculations heroAll The Calculations

time calculator

Unix Timestamp Converter

Translate between human-readable dates and Unix timestamps (seconds since 1 Jan 1970 UTC).

Results

Timestamp from date
1736942400.00
Converted year
1970.00
Converted month
1.00
Converted day
1.00
Converted hour
0.00
Converted minute
0.00
Converted second
0.00
Readable UTC time
1970-01-01 00:00:00 UTC

Overview

Unix timestamps show up everywhere in modern systems—API payloads, log files, webhook signatures, database records, cache keys, and more. They’re compact and unambiguous, but they’re not fun to read with the naked eye. This Unix timestamp converter gives you a quick way to translate between human‑friendly dates and “seconds since 1 January 1970 UTC” so you can debug issues, inspect data, or sanity‑check schedules without opening a terminal or writing throwaway scripts.

How to use this calculator

  1. Decide which direction you need to convert: from a human date to a Unix timestamp, or from a Unix timestamp back to a human‑readable date.
  2. For date → timestamp, enter the year, month, day, hour, minute, and second you care about. Use 24‑hour time for the hour field (0–23) to avoid AM/PM ambiguity.
  3. For timestamp → date, paste the Unix timestamp value (in whole seconds) into the existing timestamp field. If your source is in milliseconds, divide it by 1,000 first.
  4. Review the calculated Unix timestamp for your date, or the converted UTC date/time for your timestamp. Both views update together so you can sanity‑check your input.
  5. Compare the human‑readable UTC output with your logs, API docs, or monitoring tools to verify that you are looking at the right moment in time.
  6. Adjust fields as needed to test nearby times—for example, incrementing a TTL by an hour or shifting a scheduled job to a different day—and watch how the corresponding timestamp changes.

Inputs explained

Year
The four‑digit calendar year of the date you want to convert. Unix time is defined for a wide range of years, but most application data lives near the current year.
Month
The calendar month number (1–12). Internally this will be mapped to the correct month index when constructing the UTC date used for the conversion.
Day
The day of the month (1–31) corresponding to the date you want to convert. Be sure the combination of year, month, and day represents a valid calendar date.
Hour (0–23)
The hour of the day in 24‑hour UTC time. For example, 0 represents midnight, 12 represents noon, and 23 represents 11 PM UTC.
Minute
The minute of the hour (0–59). Together with hour and second, this specifies the exact instant in UTC you want to convert.
Second
The second of the minute (0–59). Unix timestamps typically store whole seconds, so fractional seconds are not used here.
Existing Unix timestamp
A numeric timestamp representing whole seconds since 1 January 1970 00:00:00 UTC. Paste values from logs, JWTs, API payloads, or database fields here to see their corresponding UTC date/time.

How it works

Unix time (also called epoch time) counts whole seconds since 00:00:00 on 1 January 1970 in Coordinated Universal Time (UTC), ignoring leap seconds. A timestamp like 1,700,000,000 represents a specific second on that global clock.

When you enter a calendar date and time—year, month, day, hour, minute, and second—the calculator constructs a UTC date from those fields and then computes the number of seconds between that instant and the Unix epoch start. Internally, it is equivalent to using a `Date.UTC(…)` style call, then dividing the resulting milliseconds by 1,000 and truncating to an integer.

Going in the other direction, when you paste a Unix timestamp into the input field, the calculator multiplies it by 1,000 to get milliseconds, constructs a UTC date object at that instant, and then extracts the year, month, day, hour, minute, and second components.

Because Unix timestamps are defined in UTC, the conversions in this tool intentionally ignore your local timezone offset. That ensures that a given numeric timestamp always maps to the same UTC date/time here as it does in your servers and APIs.

The output includes both individual numeric date parts (year, month, day, hour, minute, second) and a combined human‑readable UTC string. That makes it easy to compare against logs, database rows, or external documentation that refer to specific times.

If you are working with millisecond or microsecond precision, you can still use the calculator by manually trimming or scaling the value (for example, dividing a millisecond timestamp by 1,000 to convert it to whole seconds before pasting).

Formula

Unix timestamp (seconds) = floor(Date.UTC(year, month, day, hour, minute, second) ÷ 1000)
Converted UTC date = Date constructed from (Unix timestamp × 1000 milliseconds) and then decomposed into year, month, day, hour, minute, and second.

When to use it

  • A backend engineer is debugging an authentication error and needs to check whether a token’s `exp` (expiration) field, stored as a Unix timestamp, lines up with the expected expiry window.
  • A data analyst is reviewing event logs from a streaming pipeline and wants to convert certain timestamp fields into human‑readable times to investigate spikes or gaps.
  • A developer is scheduling a maintenance window and needs to convert a planned UTC time into an epoch value to plug into a feature flag, cron system, or deployment script.
  • A support engineer is helping a customer interpret timestamps shown in a monitoring dashboard that reports values in Unix time instead of formatted dates.

Tips & cautions

  • Always confirm whether a given timestamp is in seconds, milliseconds, or microseconds. Many JavaScript systems use milliseconds by default, while many APIs and databases prefer seconds.
  • Remember that Unix timestamps are UTC‑based. If your source time is expressed in local time (for example, “2025‑06‑01 10:00 local”), convert it to UTC first or mentally account for the timezone offset when entering values.
  • When comparing timestamps from different systems, make sure they are all using the same epoch convention. Some older or specialized systems use alternate epochs—this tool assumes the standard Unix epoch of 1970‑01‑01 UTC.
  • If you see off‑by‑one‑hour discrepancies around spring or fall transitions, it is almost always due to daylight saving time being applied on the local side. The underlying Unix timestamp remains constant.
  • The calculator focuses on whole‑second precision. It does not model leap seconds or sub‑second fractions, which are rarely needed for typical application‑level debugging.
  • Timezone selection is intentionally omitted; all conversions are performed in UTC to match the Unix timestamp specification. You must handle local time conversion separately.
  • Some very early or very distant future dates may not be representable in all environments due to underlying date library limits, especially before 1900 or far beyond 2100.
  • The tool assumes the proleptic Gregorian calendar, which is standard for computing, but historical dates prior to calendar reforms may not align with historical records.

Worked examples

Convert a scheduled deployment time to a Unix timestamp

  • You plan a deployment for 2025‑01‑15 at 12:00:00 UTC.
  • Enter year = 2025, month = 1, day = 15, hour = 12, minute = 0, second = 0.
  • The calculator reports a Unix timestamp of 1,736,932,800.
  • You can now plug 1736932800 into your deployment scripts or feature flags as a precise schedule marker.

Decode a token expiration timestamp from an API response

  • An access token includes `"exp": 1704067200`.
  • Paste 1704067200 into the existing Unix timestamp field.
  • The converter shows 2023‑12‑31 00:00:00 UTC as the expiration time.
  • You confirm that this lines up with the documented token lifetime and your user’s experience.

Compare local time vs UTC for troubleshooting DST issues

  • A log entry shows an event at Unix time 1,710,000,000.
  • You paste 1710000000 into the converter and see the UTC date/time.
  • You then compare that UTC time with your local timezone (for example, UTC‑5 or UTC+2) to understand when the event occurred in local clock time.
  • Any one‑hour differences around DST transitions become clear as timezone artifacts rather than bugs in your timestamp handling.

Deep dive

This Unix timestamp converter makes it easy to flip between human‑readable dates and raw epoch seconds for debugging, log analysis, and API work. Instead of writing throwaway scripts or relying on ad‑hoc shell commands, you can paste a timestamp or type in a date and instantly see the corresponding UTC value in both formats.

It is especially useful when working with JWT expirations, cache TTLs, database records, or event streams that store time as integers. By keeping everything in UTC and focusing on the standard 1970 epoch, the tool helps you avoid common timezone and daylight‑saving‑time pitfalls.

Because the inputs and outputs are explicit—year, month, day, hour, minute, second, and epoch seconds—you can double‑check assumptions with teammates, copy values into code or configuration, and build a repeatable workflow around time conversions.

FAQs

Is the conversion performed in UTC or local time?
All conversions are performed in UTC to match how Unix timestamps are defined. The numeric timestamp you see here should match what your backend systems use when treating values as epoch seconds.
Can this tool handle millisecond or microsecond timestamps?
It is designed for second‑based Unix timestamps. For millisecond values, divide by 1,000 before pasting and multiply the resulting seconds by 1,000 if you need to convert back. Microsecond and nanosecond formats should be scaled similarly.
Why is the converted time different from what I see in my local logs?
Most local tools display times in your system timezone, while Unix timestamps are UTC‑based. Convert your log times to UTC or mentally apply your timezone offset when comparing them to the UTC output here.
Can I convert negative Unix timestamps for dates before 1970?
Yes. Negative timestamps represent dates before the Unix epoch. Paste them into the timestamp field to see the corresponding UTC date, as long as the date falls within the supported range of the underlying date library.
Does daylight saving time affect Unix timestamps?
No. A Unix timestamp always refers to an absolute moment in UTC. Daylight saving time only affects how local timezones display that moment on clocks, not the underlying epoch value.
Is this tool suitable for legal or financial timekeeping?
It is a convenient debugging aid, not a legal time reference. For compliance‑sensitive use cases, rely on authoritative time sources and your production systems’ logs rather than manual conversions alone.

Related calculators

time

Add Days to Date Calculator

Add or subtract days from any date and get the resulting calendar date instantly.

time

Subtract Days from Date Calculator

Work backward from any due date by subtracting a set number of days to see when prep work must begin.

time

Business Days Calculator

Add business days to a start date while skipping weekends automatically.

time

Work Hours Calculator

Calculate total hours worked between two times, factoring in unpaid breaks and overnight shifts.

This Unix timestamp converter is provided for debugging and educational purposes only. It relies on standard UTC date calculations and does not account for every historical or timezone nuance. Always verify mission‑critical timestamps directly within your production systems, logs, or databases before making operational, legal, or financial decisions based on these values.