How do I know if a timestamp is in seconds or milliseconds?

Count the digits. For current dates, 10 digits are seconds, 13 are milliseconds, 16 are microseconds and 19 are nanoseconds. The converter counts them for you and shows the unit it used. If the result doesn't make sense, pick the unit by hand.

Why does my date show up in 1970?

The value is in seconds and was read as milliseconds. In JavaScript, new Date(1790254800) gives January 21, 1970, while new Date(1790254800 * 1000) gives the right date. The reverse happens too: milliseconds read as seconds become a date far in the future.

Does a timestamp depend on the time zone?

No. The epoch is always counted from 1970 in UTC and is the same in every country. The zone only changes the date and time shown. Here you pick the display zone and see UTC and ISO 8601 at the same time.

Why does an old São Paulo date show UTC−2?

Because daylight saving time was in effect on that date; Brazil used it until February 2019. The converter uses the IANA time zone database, which has each year's rules, and flags the result as daylight saving time.

What happens to timestamps after 2038?

Nothing, if the system uses 64 bits. The 2147483647 limit (2038-01-19 03:14:07 UTC) only affects systems that store the epoch as a signed 32-bit integer, such as MySQL's TIMESTAMP type. Paste 2147483648 here to see the next second.

Can a timestamp be negative?

Yes. Negative numbers are dates before January 1, 1970. The converter accepts negative values in any unit and also turns old dates into negative epochs.

How do I get the current timestamp in code?

In JavaScript, Math.floor(Date.now() / 1000) gives seconds and Date.now() gives milliseconds. In Python, int(time.time()). In Java, Instant.now().getEpochSecond(). In a shell, date +Unix Timestamp Converter: Epoch to Date and Date to Epoch - Código ao Ponto. The code section on this page also covers SQL and converting both ways.

Are the log lines I paste sent to a server?

No. The conversion runs in the browser, and pasted values are neither sent nor stored. Usage metrics only record the detected unit and the kind of conversion, never the content.

Unix Timestamp Converter

Paste an epoch in seconds, milliseconds, microseconds or nanoseconds and see the date in your time zone, in UTC and in ISO 8601. The unit is detected from the number of digits. You can also paste a date to get its epoch.

Current timestamp

Timestamp or date

No value yet

Paste a timestamp or a date in the field. Every format shows up here right away, each with a copy button.

Unit

Time zone for the date

Date to timestamp

Pick a date and time. The epoch is calculated in the UTC zone, the one selected above.

Date Time

Add or subtract time, useful for test data with past or future dates

Convert log lines

Paste log, JSON or CSV lines. Every number with 10, 13, 16 or 19 digits becomes an ISO 8601 date in the UTC zone. The lines stay in your browser.

Did the timestamp come from a JWT exp, iat or nbf? The decoder shows the whole token and tells you whether it has expired.

Decode JWT

Just need a date as an ISO string or UTC string? The date format converter does that in one click.

Format a date

Timestamps in code

How to get the current timestamp and convert it both ways in common languages.

// Now, in seconds and in milliseconds
Math.floor(Date.now() / 1000); // 1790254800
Date.now();                    // 1790254800123

// Epoch to date (Date expects milliseconds)
new Date(1790254800 * 1000).toISOString();

// Date to epoch in seconds
Math.floor(new Date("2026-09-24T10:00:00-03:00").getTime() / 1000);

What is a Unix timestamp

A Unix timestamp, or epoch, is the number of seconds since January 1, 1970 at 00:00:00 UTC, not counting leap seconds. The same number stands for the same instant anywhere in the world, which is why it shows up in database columns, logs, message queues, API responses and the exp, iat and nbf claims of a JWT. The time zone only matters when a date is shown to a person.

Seconds, milliseconds, microseconds or nanoseconds

The unit isn't written in the number. For dates between 2001 and 2286 the digit count settles it: each finer unit adds 3 digits. That is how this converter detects the unit.

Digits	Unit	Example	Where it usually shows up
10	Seconds	1790254800	PHP time(), Python int(time.time()), JWT exp, PostgreSQL EXTRACT(EPOCH), RabbitMQ timestamp property
13	Milliseconds	1790254800000	JavaScript Date.now(), Java System.currentTimeMillis(), Kafka record timestamp, SQS SentTimestamp
16	Microseconds	1790254800000000	BigQuery UNIX_MICROS, Python time.time_ns() // 1000, tracing
19	Nanoseconds	1790254800000000000	Go UnixNano(), Python time.time_ns(), InfluxDB and metrics

UTC and local time

A timestamp has no time zone. Whoever displays it applies one: new Date(ms).toISOString() shows UTC, and toLocaleString() uses the browser's zone. That is why two computers in different zones show different times for the same value. When a date is off by a whole number of hours, it is almost always UTC being read as local time, or the other way around.

A date in 1970 or thousands of years ahead

Both symptoms come from the same unit mix-up. A value in seconds passed to JavaScript's new Date(), which expects milliseconds, becomes January 1970. A Date.now() stored in a field the backend reads as seconds becomes a date tens of thousands of years ahead. Converting the number here shows right away which one happened.

Daylight saving time and old dates

Time zone rules change over time. Brazil, for example, used daylight saving time until February 2019, and during those periods São Paulo was at UTC−2 instead of UTC−3. A system that converts old dates with a fixed offset gets everything that fell in summer wrong by one hour. The IANA time zone database, used here and by browsers, keeps each year's rules, and the result is flagged when the date falls in daylight saving time.

The year 2038 problem

The largest signed 32-bit integer is 2147483647, which is 2038-01-19 at 03:14:07 UTC. One second later, systems that store the epoch in 32 bits wrap around to 1901. MySQL's TIMESTAMP type has this limit. BIGINT columns and languages with 64-bit integers don't, and this converter accepts dates well past 2038.

Negative timestamps

Negative values are dates before 1970: −86400 is 1969-12-31 in UTC. Birth dates and historical records can produce them, and some older databases and libraries reject them. Worth adding one to your test data.

Start and end of the day in another zone

September 24 in São Paulo starts at 03:00 UTC, not at midnight UTC. A BETWEEN filter built with the start of the day in UTC returns rows from the wrong day. This converter's start and end table uses the zone you picked, and the end of a period is the last millisecond before the next one starts.

Unix timestamp FAQ

Units, time zones and the date bugs that show up most in logs and APIs.