What's the difference between seconds and milliseconds?

Unix time is traditionally in seconds (10 digits for current dates). JavaScript's Date.now() returns milliseconds (13 digits). Divide by 1000 to convert ms to seconds. APIs vary - check documentation.

What is the Year 2038 problem?

32-bit signed integers overflow on January 19, 2038 at 03:14:07 UTC. After this, timestamps wrap to negative (appearing as 1901). Solution: use 64-bit timestamps or database datetime types. Most modern systems already use 64-bit.

How do I handle timezones with timestamps?

Store all timestamps in UTC. Convert to local timezone only for display. Date inputs should be converted to UTC before creating timestamps. This prevents daylight saving and timezone ambiguity issues.

Can timestamps represent dates before 1970?

Yes, with negative numbers. December 31, 1969 23:59:59 UTC is -1. However, some systems don't support negative timestamps. For historical dates, consider using ISO 8601 strings or separate date fields.

Unix Timestamp Converter

Guide & TutorialOffline

Convert between Unix timestamps and human-readable dates

Convert between Unix timestamps and human-readable dates instantly with our free online timestamp converter. This tool helps developers, database administrators, and system engineers convert epoch time to readable dates and vice versa. Simply enter a Unix timestamp or select a date to get instant conversions with timezone support.

Current Unix Timestamp

1782560150

Saturday, June 27, 2026 at 11:35:50 AM UTC

Timestamp to Date

Unix Timestamp (seconds)

Human Readable

Saturday, June 27, 2026 at 11:35:50 AM UTC

ISO 8601

Date to Timestamp

Date & Time

Quick Actions

About Unix Timestamps

Unix timestamp is the number of seconds that have elapsed since January 1, 1970 (midnight UTC/GMT), not counting leap seconds. This is commonly used in programming and databases to represent dates and times.

About Unix Timestamp Converter

Unix timestamp conversion transforms between human-readable dates and Unix time (seconds since January 1, 1970 UTC). Timestamps are the standard way to store and transmit dates in databases, APIs, and programming - they're timezone-agnostic, sortable, and compact.

How It Works

Unix timestamp counts seconds from the Unix Epoch (1970-01-01 00:00:00 UTC). Positive numbers are dates after 1970, negative before. The converter parses human dates, calculates the timestamp, or converts timestamps back to formatted dates considering timezone offsets.

Technical Details

Unix time is a 32-bit signed integer (Y2K38 problem hits in 2038) or 64-bit for extended range. JavaScript uses milliseconds (divide by 1000 for seconds). UTC is the reference timezone - always convert to/from UTC for storage, localize for display. Leap seconds are typically ignored.

Common Use Cases

API Date Fields

APIs commonly transmit dates as Unix timestamps for consistency.

1703980800 represents 2023-12-31 00:00:00 UTC

Database Storage

Store dates as integers for efficient indexing and comparison.

Log Analysis

Convert log timestamps to human-readable dates for debugging.

Scheduling

Calculate future dates by adding seconds to current timestamp.

Cache Expiration

Set expiry times as timestamps for cache headers.

Code Examples

JavaScript

javascript

// Current timestamp (seconds)
const now = Math.floor(Date.now() / 1000);

// Date to timestamp
const date = new Date('2024-01-01T00:00:00Z');
const timestamp = Math.floor(date.getTime() / 1000);

// Timestamp to date
const ts = 1704067200;
const dateFromTs = new Date(ts * 1000);
dateFromTs.toISOString();  // "2024-01-01T00:00:00.000Z"

// Local formatted date
dateFromTs.toLocaleString('en-US', {
  timeZone: 'America/New_York'
});  // "12/31/2023, 7:00:00 PM"

JavaScript uses milliseconds, so multiply/divide by 1000 for Unix seconds. Always specify timezone for display.

Python

python

import datetime
import time

# Current timestamp
timestamp = int(time.time())

# Date to timestamp
dt = datetime.datetime(2024, 1, 1, tzinfo=datetime.timezone.utc)
timestamp = int(dt.timestamp())

# Timestamp to date
ts = 1704067200
dt = datetime.datetime.fromtimestamp(ts, tz=datetime.timezone.utc)
dt.isoformat()  # '2024-01-01T00:00:00+00:00'

# With timezone conversion
from zoneinfo import ZoneInfo
local = dt.astimezone(ZoneInfo('America/New_York'))
local.strftime('%Y-%m-%d %H:%M:%S %Z')  # '2023-12-31 19:00:00 EST'

Always use timezone-aware datetime objects. fromtimestamp with tz=utc prevents local timezone assumptions.

SQL (PostgreSQL)

sql

-- Current timestamp
SELECT EXTRACT(EPOCH FROM NOW())::INTEGER;

-- Date to timestamp
SELECT EXTRACT(EPOCH FROM '2024-01-01'::TIMESTAMP)::INTEGER;

-- Timestamp to date
SELECT TO_TIMESTAMP(1704067200);

-- Store as timestamp, display as local
SELECT created_at AT TIME ZONE 'America/New_York'
FROM events;

PostgreSQL's EXTRACT(EPOCH FROM ...) gives Unix timestamp. TO_TIMESTAMP converts back.

Tips & Best Practices

Always store timestamps in UTC, convert to local only for display
Use milliseconds for sub-second precision, seconds for most APIs
Be aware of 32-bit limitations (Y2038) in legacy systems
Include timezone when parsing date strings to avoid ambiguity
Use ISO 8601 format for human-readable date strings in APIs

Common Mistakes to Avoid

Confusing seconds and milliseconds (3 orders of magnitude!)
Storing local time instead of UTC
Parsing date strings without specifying timezone
Not handling daylight saving time transitions

When to Use This Tool

Use Unix timestamps for storing dates in databases, transmitting in APIs, comparing dates, and calculating time differences. Essential for any application dealing with time across timezones.

Frequently Asked Questions

Timestamps are: timezone-independent (no ambiguity), sortable as integers, compact (10 digits vs 20+ char string), easy to calculate differences, universally parseable. Date strings have format variations and timezone issues.

// Current timestamp (seconds) const now = Math.floor(Date.now() / 1000); // Date to timestamp const date = new Date('2024-01-01T00:00:00Z'); const timestamp = Math.floor(date.getTime() / 1000); // Timestamp to date const ts = 1704067200; const dateFromTs = new Date(ts * 1000); dateFromTs.toISOString(); // "2024-01-01T00:00:00.000Z" // Local formatted date dateFromTs.toLocaleString('en-US', { timeZone: 'America/New_York' }); // "12/31/2023, 7:00:00 PM"

import datetime import time # Current timestamp timestamp = int(time.time()) # Date to timestamp dt = datetime.datetime(2024, 1, 1, tzinfo=datetime.timezone.utc) timestamp = int(dt.timestamp()) # Timestamp to date ts = 1704067200 dt = datetime.datetime.fromtimestamp(ts, tz=datetime.timezone.utc) dt.isoformat() # '2024-01-01T00:00:00+00:00' # With timezone conversion from zoneinfo import ZoneInfo local = dt.astimezone(ZoneInfo('America/New_York')) local.strftime('%Y-%m-%d %H:%M:%S %Z') # '2023-12-31 19:00:00 EST'

-- Current timestamp SELECT EXTRACT(EPOCH FROM NOW())::INTEGER; -- Date to timestamp SELECT EXTRACT(EPOCH FROM '2024-01-01'::TIMESTAMP)::INTEGER; -- Timestamp to date SELECT TO_TIMESTAMP(1704067200); -- Store as timestamp, display as local SELECT created_at AT TIME ZONE 'America/New_York' FROM events;