Timestamp Converter

What Is a Unix Timestamp?

A Unix timestamp (also called epoch time or POSIX time) is the number of seconds that have elapsed since January 1, 1970, 00:00:00 UTC. This date is called the Unix epoch. Every second that passes increments the counter by one, giving every moment in time a single integer representation. A Unix timestamp converter translates between this integer and human-readable date formats like ISO 8601, RFC 2822, or locale-specific strings.

Unix timestamps are the standard way to represent time in computing. Databases store created_at and updated_at columns as integers or millisecond timestamps. API responses include timestamps for cache headers (Expires, Last-Modified), JWT claims (iat, exp, nbf), and event logs. Log files from nginx, syslog, and application frameworks all use epoch time. The format is unambiguous because it always represents UTC, with no timezone or daylight saving offset to misinterpret.

Converting between timestamps and dates by hand is error-prone. A value like 1711324800 gives no visual hint about the date it represents. This tool converts Unix timestamps to readable dates and dates back to timestamps. Whether you are reading a JWT exp claim, debugging a database query, or checking a log timestamp, it handles 10-digit (seconds) and 13-digit (milliseconds) values automatically.

Why Use This Timestamp Converter?

Reading raw Unix timestamps from logs, databases, or API responses requires either memorizing epoch math or writing throwaway code. This converter does it in your browser with zero setup. Whether you need to decode a JWT expiry, audit a log line, or set a database TTL, the result is one click away. The tool auto-detects whether a value is a 10-digit seconds timestamp or 13-digit milliseconds timestamp, so you never need to manually divide by 1000. All processing runs locally in your browser. No data leaves your machine, so timestamps from internal systems and sensitive logs stay private.

Timestamp Converter Use Cases

Unix Timestamp Reference Table

The table below shows well-known Unix timestamps and their corresponding dates. These values are useful for quick sanity checks, testing, and understanding the range of 32-bit and 64-bit timestamps.

Date and Time Format Comparison

Different systems and standards represent the same moment in time using different string formats. The table compares the most common formats you will encounter in APIs, logs, and databases.

Code Examples

Convert between Unix timestamps and dates in the language you are working with. Each example shows both directions: timestamp to date and date to timestamp.

// Current Unix timestamp in seconds
Math.floor(Date.now() / 1000)  // → 1711324800

// Unix timestamp to Date object
const date = new Date(1711324800 * 1000)
date.toISOString()             // → "2024-03-25T00:00:00.000Z"
date.toUTCString()             // → "Mon, 25 Mar 2024 00:00:00 GMT"

// Date string to Unix timestamp
Math.floor(new Date('2024-03-25T00:00:00Z').getTime() / 1000)
// → 1711324800

// Millisecond timestamps (common in JS APIs)
Date.now()                     // → 1711324800000 (ms)
Date.parse('2024-03-25')       // → 1711324800000 (ms)

import time
from datetime import datetime, timezone

# Current Unix timestamp
int(time.time())                                    # → 1711324800

# Unix timestamp to datetime
dt = datetime.fromtimestamp(1711324800, tz=timezone.utc)
dt.isoformat()                                      # → '2024-03-25T00:00:00+00:00'
dt.strftime('%Y-%m-%d %H:%M:%S %Z')                 # → '2024-03-25 00:00:00 UTC'

# Datetime string to Unix timestamp
dt = datetime.fromisoformat('2024-03-25T00:00:00+00:00')
int(dt.timestamp())                                  # → 1711324800

# Parse RFC 2822 dates (from email headers)
from email.utils import parsedate_to_datetime
parsedate_to_datetime('Mon, 25 Mar 2024 00:00:00 +0000').timestamp()
# → 1711324800.0

package main

import (
    "fmt"
    "time"
)

func main() {
    // Current Unix timestamp
    now := time.Now().Unix() // → 1711324800

    // Unix timestamp to time.Time
    t := time.Unix(1711324800, 0).UTC()
    fmt.Println(t.Format(time.RFC3339))
    // → 2024-03-25T00:00:00Z

    // Parse a date string to Unix timestamp
    parsed, _ := time.Parse(time.RFC3339, "2024-03-25T00:00:00Z")
    fmt.Println(parsed.Unix())
    // → 1711324800

    // Millisecond timestamp
    ms := time.Now().UnixMilli() // → 1711324800000
    fmt.Println(now, ms)
}

# Current Unix timestamp
date +%s                                    # → 1711324800

# Convert timestamp to human-readable date (GNU date)
date -d @1711324800                         # → Mon Mar 25 00:00:00 UTC 2024

# Convert timestamp to ISO 8601
date -d @1711324800 --iso-8601=seconds      # → 2024-03-25T00:00:00+00:00

# macOS (BSD date) — slightly different flags
date -r 1711324800                          # → Mon Mar 25 00:00:00 UTC 2024

# Date string to timestamp (GNU date)
date -d "2024-03-25 00:00:00 UTC" +%s       # → 1711324800

Frequently Asked Questions