Epoch/Unix Timestamp Converter

Convert between Unix timestamps and human-readable dates with timezone support.

Current Unix Timestamp
Timestamp to Date
Supports both seconds and milliseconds
Date to Timestamp

How to Use This Tool

  1. View Current Timestamp: The current Unix timestamp updates live at the top of the page in both seconds and milliseconds format.
  2. Convert Timestamp to Date: Enter a Unix timestamp (seconds or milliseconds), select your timezone, and click "Convert" to see the human-readable date in multiple formats.
  3. Convert Date to Timestamp: Select a date and time, choose your timezone, and click "Convert to Timestamp" to generate Unix timestamps.
  4. Copy Results: Use the copy buttons next to each result to copy values to your clipboard.

Understanding Unix Timestamps

A Unix timestamp represents the number of seconds (or milliseconds) that have elapsed since the Unix epoch: 1st January 1970 at 00:00:00 UTC. This standardised format is used extensively in:

  • Database systems and log files
  • API responses and web services
  • Programming languages and frameworks
  • File systems and operating systems
  • Network protocols and security tokens

Common Timestamp Formats

Format Example Description
Unix (seconds) 1704067200 Standard Unix timestamp, 10 digits
Unix (milliseconds) 1704067200000 JavaScript-style, 13 digits
ISO 8601 2024-01-01T00:00:00Z International standard format
UK Format 01/01/2024 00:00:00 Day/Month/Year (DD/MM/YYYY)
US Format 01/01/2024 12:00:00 AM Month/Day/Year (MM/DD/YYYY)
Frequently Asked Questions

A Unix timestamp (also known as epoch time or POSIX time) is the number of seconds that have elapsed since 1st January 1970 at 00:00:00 UTC. This date is called the Unix epoch. It's a widely used standard for representing time in computing systems.

The Unix epoch of 1st January 1970 was chosen by the original Unix developers at Bell Labs. It was a convenient recent date at the time Unix was being developed in the early 1970s, and it allows for a reasonable range of dates to be represented with 32-bit integers.

A Unix timestamp in seconds counts whole seconds since the epoch (e.g., 1704067200). A milliseconds timestamp is 1000 times larger and includes millisecond precision (e.g., 1704067200000). JavaScript and many APIs use milliseconds, whilst Unix systems traditionally use seconds.

The Year 2038 problem affects systems using 32-bit signed integers to store Unix timestamps. On 19th January 2038 at 03:14:07 UTC, the timestamp will overflow the maximum 32-bit value (2,147,483,647). Most modern systems now use 64-bit integers, which won't overflow for billions of years.

Unix timestamps are always in UTC (Coordinated Universal Time) and are timezone-independent. When converting a timestamp to a human-readable date, you apply a timezone offset. This makes timestamps ideal for storing and comparing times across different geographical locations.
Quick Reference
Notable Timestamps
  • 0 - Unix Epoch (1 Jan 1970)
  • 1000000000 - 9 Sep 2001
  • 1234567890 - 13 Feb 2009
  • 2000000000 - 18 May 2033
  • 2147483647 - 19 Jan 2038 (32-bit limit)
Time Conversions
  • 1 minute = 60 seconds
  • 1 hour = 3,600 seconds
  • 1 day = 86,400 seconds
  • 1 week = 604,800 seconds
  • 1 year = ~31,536,000 seconds
Related Tools
Developer Tips

JavaScript:

// Current timestamp (ms)
Date.now()

// To seconds
Math.floor(Date.now() / 1000)

// From timestamp
new Date(timestamp * 1000)

PHP:

// Current timestamp
time()

// From timestamp
date('Y-m-d H:i:s', $ts)

// To timestamp
strtotime('2024-01-01')

Python:

import time
# Current timestamp
time.time()

from datetime import datetime
# From timestamp
datetime.fromtimestamp(ts)