Timestamp - Complete Guide

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

1. API Date Fields: APIs commonly transmit dates as Unix timestamps for consistency.
   • Example: 1703980800 represents 2023-12-31 00:00:00 UTC
2. Database Storage: Store dates as integers for efficient indexing and comparison.
3. Log Analysis: Convert log timestamps to human-readable dates for debugging.
4. Scheduling: Calculate future dates by adding seconds to current timestamp.
5. Cache Expiration: Set expiry times as timestamps for cache headers.

Code Examples

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

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)

-- 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

Why use timestamps instead of date strings?

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.

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.

Get Started

Ready to try Timestamp? Use the tool now - it's free, fast, and works right in your browser.

---

Last updated: June 27, 2026