Unix Timestamps: What They Are and How to Work With Them

What is a Unix Timestamp?

Unix timestamps are just a count of seconds since January 1, 1970 UTC — that's it. No timezones, no DST, no locale weirdness. It's the reason they're so useful: you can compare two timestamps with a single integer subtraction, and any language on any platform knows how to work with them.

For example, the Unix timestamp for January 1, 2025 at midnight UTC is 1735689600, meaning that 1,735,689,600 seconds have elapsed since January 1, 1970.

Why Use Unix Timestamps?

Unix timestamps offer several advantages over human-readable date formats:

• Timezone independent: Timestamps represent a single point in time regardless of timezone
• Easy to compare: Comparing two timestamps is simple integer comparison
• Easy math: Adding or subtracting time is just arithmetic
• Compact storage: A single integer vs. complex date strings
• Language agnostic: Every programming language understands timestamps

Seconds vs. Milliseconds

You'll encounter two common forms of Unix timestamps:

• Seconds (10 digits): Standard Unix time, e.g., 1735689600
• Milliseconds (13 digits): Higher precision, e.g., 1735689600000

JavaScript's Date.now() returns milliseconds, while most Unix systems use seconds. Always check which format an API expects or returns.

Working with Timestamps in Code

JavaScript

// Get current timestamp in milliseconds
const nowMs = Date.now();

// Get current timestamp in seconds
const nowSec = Math.floor(Date.now() / 1000);

// Convert timestamp to Date object
const date = new Date(1735689600 * 1000);

// Convert Date to timestamp
const timestamp = Math.floor(date.getTime() / 1000);

Python

import time
from datetime import datetime

# Get current timestamp
now = int(time.time())

# Convert timestamp to datetime
dt = datetime.fromtimestamp(1735689600)

# Convert datetime to timestamp
timestamp = int(dt.timestamp())

The Y2K38 Problem

Traditional Unix timestamps are stored as signed 32-bit integers, which can represent values up to 2,147,483,647. This maximum value corresponds to January 19, 2038 at 03:14:07 UTC. After this moment, 32-bit systems will overflow and wrap around to negative numbers.

Common Pitfalls

• Timezone confusion: Timestamps are UTC. Always convert to/from UTC explicitly.
• Seconds vs. milliseconds: Know which format your tools expect.
• Leap seconds: Unix time ignores leap seconds. For most applications, this doesn't matter.
• Daylight Saving Time: Timestamps aren't affected by DST, but conversions to local time are.

Best Practices

1. Store times as UTC timestamps in your database
2. Convert to local time only for display
3. Use established libraries for date manipulation
4. Be explicit about seconds vs. milliseconds in your code
5. Document which timestamp format your APIs use

Conclusion

Unix timestamps provide a simple, universal way to represent time in computing. By understanding how they work and following best practices, you can avoid common date-time bugs and build more robust applications. Whether you're storing data, building APIs, or debugging logs, a solid understanding of Unix time will serve you well.