Unix Timestamp Converter Online — Epoch Time Guide

What Is a Unix Timestamp?

A Unix timestamp (also called epoch time or POSIX time) is a single integer counting the number of seconds elapsed since January 1, 1970 at 00:00:00 UTC — the Unix epoch. The current timestamp as of 2026 is approximately 1,747,000,000.

The key advantage of Unix timestamps is that they are timezone-independent. The same integer represents the same instant everywhere on Earth, so two servers in different countries recording "1700000000" agree on exactly which moment that was. The conversion to a human-readable string only happens at display time, using whichever timezone the viewer is in.

How to Convert a Unix Timestamp

1. Open the Unix Timestamp Converter.
2. Select direction: Timestamp → Human to decode a timestamp, or Human → Timestamp to encode a date.
3. Choose precision: seconds (10-digit) or milliseconds (13-digit).
4. Enter the timestamp or pick a date, then click Convert.
5. The result shows UTC, ISO 8601, your local time, and a relative label.
6. Click Use Now to instantly load the current timestamp.

Seconds vs Milliseconds: Which Do You Have?

The most common source of confusion with Unix timestamps is the precision. Count the digits:

If your timestamp has 13 digits, divide by 1000 before converting, or switch the converter's precision to milliseconds.

UTC, Local Time, and ISO 8601

A Unix timestamp converts to three commonly used human-readable formats:

• UTC — Coordinated Universal Time, the global reference. Example: Mon, 15 Jan 2024 14:30:00 GMT.
• ISO 8601 — The international standard, always UTC with a Z suffix. Example: 2024-01-15T14:30:00.000Z. Sortable as a string, supported everywhere.
• Local time — Converted to the viewer's browser timezone. The same timestamp shows as 9:30am EST or 2:30pm GMT.

When storing timestamps in a database, always store in UTC (Unix timestamp or TIMESTAMPTZ). Convert to local time only when displaying to a user.

Code Examples

JavaScript / Node.js

// Current timestamp
const nowSeconds = Math.floor(Date.now() / 1000);   // 1700000000
const nowMs = Date.now();                            // 1700000000000

// Timestamp to Date
const d = new Date(1700000000 * 1000);
console.log(d.toISOString());     // "2023-11-14T22:13:20.000Z"
console.log(d.toUTCString());     // "Tue, 14 Nov 2023 22:13:20 GMT"
console.log(d.toLocaleString());  // local timezone string

// Date to timestamp
const ts = Math.floor(new Date('2024-01-15T14:30:00Z').getTime() / 1000);

Python

import time
from datetime import datetime, timezone

# Current timestamp
now = int(time.time())                  # seconds
now_ms = int(time.time() * 1000)        # milliseconds

# Timestamp to datetime (UTC)
dt_utc = datetime.fromtimestamp(1700000000, tz=timezone.utc)
print(dt_utc.isoformat())              # "2023-11-14T22:13:20+00:00"

# Datetime to timestamp
dt = datetime(2024, 1, 15, 14, 30, tzinfo=timezone.utc)
ts = int(dt.timestamp())

SQL

-- PostgreSQL: timestamp to Unix
SELECT EXTRACT(EPOCH FROM NOW())::BIGINT;          -- current Unix timestamp
SELECT EXTRACT(EPOCH FROM created_at)::BIGINT       -- column to Unix
  FROM orders;

-- PostgreSQL: Unix to timestamp
SELECT TO_TIMESTAMP(1700000000) AT TIME ZONE 'UTC';

-- MySQL: timestamp to Unix
SELECT UNIX_TIMESTAMP(NOW());
SELECT UNIX_TIMESTAMP(created_at) FROM orders;

-- MySQL: Unix to datetime
SELECT FROM_UNIXTIME(1700000000);

The Year 2038 Problem

32-bit signed integers can hold values up to 2,147,483,647. That timestamp corresponds to January 19, 2038 at 03:14:07 UTC. On systems using a 32-bit integer to store the Unix timestamp, the value will overflow and wrap to a large negative number — causing dates to appear as December 13, 1901.

This affects embedded systems, old 32-bit kernels, and legacy databases usingINT(11) columns for timestamps. All 64-bit systems and modern databases are unaffected — a 64-bit signed integer can represent dates more than 292 billion years into the future.

If you are working with MySQL and storing timestamps as TIMESTAMP columns (which are internally 32-bit on older MySQL versions), consider migrating toDATETIME or BIGINT to avoid 2038 issues.

Common Reference Timestamps

Common Questions

Why does my timestamp show a date in 1970?

If a 13-digit millisecond timestamp is treated as seconds, the resulting date will be around 55,000 years in the future. Conversely, if a 10-digit seconds timestamp is treated as milliseconds, the result will be in 1970 (a very small number of milliseconds after the epoch). Switch the precision toggle to match your timestamp's format.

What timezone does "local" mean?

Local time uses your browser's detected timezone — the same timezone your OS is set to. When converting a date to a Unix timestamp using the date picker, the input is interpreted as local time. If you need to input a UTC datetime, adjust for your UTC offset manually, or enter the equivalent Unix timestamp directly.

Can I convert a negative timestamp?

Yes. Negative Unix timestamps represent dates before January 1, 1970. The tool handles these correctly — timestamp -315619200 corresponds to January 1, 1960 UTC.