Timestamp Converter (UNIX ↔ Date)

Convert epoch seconds/milliseconds to human-readable dates—and back. Private by design (100% client-side).

Inputs & Actions

Parsing stays browser-default; this only affects displayed results.
Current Epoch: s · ms

Result

Result:

Batch Convert (one value per line)

5 Fun Facts about UNIX Timestamps

Zero is a birthday

A timestamp of 0 is the exact start of the Unix Epoch: 1970-01-01T00:00:00Z (UTC).

Epoch start

Count the digits

10 digits = seconds; 13 digits = milliseconds. Add or remove three zeros to hop between them.

Seconds vs ms

Same instant, different clocks

Timestamps are timezone-agnostic. London, New York, or Tokyo show different local times—but it’s the same moment.

Timezone-agnostic

The 2038 “oops”

On 2038-01-19 03:14:07 UTC, 32-bit second counters overflow. Modern 64-bit systems avoid this.

32-bit limit

“Z” means Zulu (UTC)

In ISO-8601, the trailing Z (e.g., 2025-03-01T10:30:00Z) means UTC—the same time everywhere.

ISO-8601

About UNIX / Epoch Time

A UNIX timestamp (often called epoch time) is a single number that counts how much time has passed since the Unix Epoch: 1970-01-01T00:00:00Z (UTC). It’s widely used in logs, databases, and APIs because it’s compact, sortable, and timezone-agnostic.

Quick facts

  • Seconds vs milliseconds vs nanoseconds:
    • 10 digits → seconds (e.g., 1700000000)
    • 13 digits → milliseconds (e.g., 1700000000000)
    • 16 digits → microseconds (e.g., 1700000000000000)
    • 19 digits → nanoseconds (commonly from high-precision systems)
  • Timezone-agnostic: the number represents an absolute moment; only its display changes with timezone/DST.
  • Negative values represent dates before 1970-01-01 (e.g., -31536000 → 1969-01-01T00:00:00Z).
  • Y2038 limit (32-bit seconds): 2147483647 → 2038-01-19T03:14:07Z. Modern systems use 64-bit and don’t suffer this limit.

Common examples

MeaningSecondsMillisecondsUTC (ISO-8601)
Epoch start 0 0 1970-01-01T00:00:00Z
One billion seconds 1000000000 1000000000000 2001-09-09T01:46:40Z
2038 boundary (32-bit) 2147483647 2147483647000 2038-01-19T03:14:07Z
Example current-era 1600000000 1600000000000 2020-09-13T12:26:40Z

Time zones & DST

  • A timestamp is stored in UTC. When you view it in “Europe/London” or “America/New_York,” only the rendered string changes.
  • DST jumps don’t change the underlying timestamp; they change how local time is displayed.
  • For unambiguous strings, prefer ISO-8601 like 2025-03-01T10:30:00Z or with an offset (e.g., +01:00).

Parsing tips

  • Browsers interpret a date string without a timezone in the user’s local timezone:
    • 2025-03-01 10:30:00 → local time
    • 2025-03-01T10:30:00Z → UTC (the trailing Z means Zulu/UTC)
    • 2025-03-01T10:30:00+05:30 → UTC+5:30
  • If you paste a 10-digit number (seconds) but expect milliseconds, multiply by 1000.
  • If you paste a 19-digit value (nanoseconds), divide by 1,000,000 to get milliseconds.

When to use which unit?

  • Seconds: many back-end APIs, databases, shell tools.
  • Milliseconds: JavaScript Date, browsers, most front-end code.
  • Nanoseconds: high-precision logs/telemetry; convert to ms for JS Date.

Epoch time by language (quick recipes)

Copy–paste friendly snippets for common tasks: get current epoch, convert a human date → epoch, and convert epoch → date.

JavaScript (Browser & Node) 
// current epoch
const s  = Math.floor(Date.now() / 1000); // seconds
const ms = Date.now();                     // milliseconds

// date → epoch
const dt = new Date("2025-03-01T10:30:00Z");
const epochSeconds = Math.floor(dt.getTime() / 1000);

// epoch → date
const d1 = new Date(1700000000 * 1000); // seconds → ms
const d2 = new Date(1700000000000);     // ms
Python 
import time, datetime, calendar

# current epoch
sec = time.time()          # float seconds
ms  = round(time.time()*1000)

# date → epoch (UTC)
dt = datetime.datetime(2025, 3, 1, 10, 30, tzinfo=datetime.timezone.utc)
epoch_seconds = int(dt.timestamp())

# epoch → date (UTC)
dt2 = datetime.datetime.fromtimestamp(1700000000, tz=datetime.timezone.utc)
Java 
import java.time.*;

long sec = Instant.now().getEpochSecond();      // current epoch (s)
long ms  = Instant.now().toEpochMilli();        // current epoch (ms)

// date → epoch
Instant ins = Instant.parse("2025-03-01T10:30:00Z");
long epochSeconds = ins.getEpochSecond();

// epoch → date
Instant ins2 = Instant.ofEpochSecond(1700000000);
ZonedDateTime zdt = ins2.atZone(ZoneId.of("UTC"));
C# (.NET) 
using System;

long sec = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
long ms  = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

// date → epoch
var dto = new DateTimeOffset(2025, 3, 1, 10, 30, 0, TimeSpan.Zero);
long epochSeconds = dto.ToUnixTimeSeconds();

// epoch → date
var dto2 = DateTimeOffset.FromUnixTimeSeconds(1700000000); // UTC
Go 
package main
import ("fmt"; "time")

func main() {
  sec := time.Now().Unix()        // seconds
  ms  := time.Now().UnixMilli()   // milliseconds

  // date → epoch (UTC)
  t, _ := time.Parse(time.RFC3339, "2025-03-01T10:30:00Z")
  fmt.Println(t.Unix())

  // epoch → date
  t2 := time.Unix(1700000000, 0).UTC()
  fmt.Println(t2.Format(time.RFC3339))
}
PHP 
// current epoch
$sec = time();                   // seconds
$ms  = round(microtime(true)*1000);

// date → epoch (UTC recommended)
$dt = new DateTime("2025-03-01T10:30:00Z");
$epoch = $dt->getTimestamp();

// epoch → date
$dt2 = (new DateTime())->setTimestamp(1700000000)->setTimezone(new DateTimeZone("UTC"));
echo $dt2->format(DATE_RFC3339);
Ruby 
# current epoch
s  = Time.now.to_i       # seconds
ms = (Time.now.to_f*1000).to_i

# date → epoch (UTC)
t  = Time.utc(2025,3,1,10,30,0)
s2 = t.to_i

# epoch → date
t2 = Time.at(1700000000).utc
Rust 
use std::time::{SystemTime, UNIX_EPOCH, Duration};

// current epoch
let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
let sec = now.as_secs();
let ms  = now.as_millis();

// epoch → date (example with chrono)
use chrono::{DateTime, Utc, TimeZone};
let d: DateTime<Utc> = Utc.timestamp_opt(1_700_000_000, 0).unwrap();
Kotlin 
import java.time.Instant
import java.time.ZoneId

val sec = Instant.now().epochSecond
val ms  = Instant.now().toEpochMilli()

// date → epoch
val ins = Instant.parse("2025-03-01T10:30:00Z")
val epochSeconds = ins.epochSecond

// epoch → date
val zdt = Instant.ofEpochSecond(1700000000).atZone(ZoneId.of("UTC"))
Swift 
import Foundation

let sec = Int(Date().timeIntervalSince1970)       // seconds
let ms  = Int(Date().timeIntervalSince1970 * 1000)

// date → epoch (ISO8601)
let iso = ISO8601DateFormatter().date(from: "2025-03-01T10:30:00Z")!
let epoch = Int(iso.timeIntervalSince1970)

// epoch → date
let d = Date(timeIntervalSince1970: 1700000000)
C++ (C++11+) 
#include <chrono>
using namespace std::chrono;

// current epoch
auto now  = system_clock::now();
auto sec  = duration_cast<seconds>(now.time_since_epoch()).count();
auto ms   = duration_cast<milliseconds>(now.time_since_epoch()).count();

// epoch → time_point
auto tp = system_clock::time_point{seconds{1700000000}};
Bash / Unix shell 
# current epoch
date +%s                # seconds
python3 - <<'PY'\nimport time; print(round(time.time()*1000))\nPY  # ms fallback

# date → epoch (UTC)
date -u -d "2025-03-01 10:30:00" +%s

# epoch → date (local or -u for UTC)
date -d @1700000000
PowerShell 
# current epoch
$sec = [int][double]::Parse((Get-Date (Get-Date).ToUniversalTime() -UFormat %s))
$ms  = [int]([DateTimeOffset]::UtcNow.ToUnixTimeMilliseconds())

# epoch → date
[DateTimeOffset]::FromUnixTimeSeconds(1700000000).UtcDateTime
PostgreSQL 
-- current epoch (seconds)
SELECT EXTRACT(EPOCH FROM NOW());

-- date → epoch (UTC)
SELECT EXTRACT(EPOCH FROM TIMESTAMP '2025-03-01 10:30:00+00');

-- epoch → timestamp
SELECT TO_TIMESTAMP(1700000000) AT TIME ZONE 'UTC';
MySQL / MariaDB 
-- current epoch
SELECT UNIX_TIMESTAMP();

-- date → epoch (assumes UTC string if suffixed with 'Z')
SELECT UNIX_TIMESTAMP('2025-03-01 10:30:00');

-- epoch → datetime
SELECT FROM_UNIXTIME(1700000000);

Tip: prefer ISO-8601 strings (e.g., 2025-03-01T10:30:00Z) for unambiguous UTC. If an API expects seconds but you have milliseconds, divide by 1000 (and multiply for the reverse).

FAQs

Is a UNIX timestamp affected by time zones?

No. The timestamp encodes an absolute moment; only its display changes with time zone or DST rules.

Seconds vs. milliseconds—what should I use?

Back-end systems and APIs often use seconds; browsers and JavaScript typically use milliseconds. This tool handles both.

Can I copy results in ISO-8601?

Yes—use the UTC output for ISO-8601 style strings like YYYY-MM-DDTHH:mm:ssZ.

Is it private?

Yes. Everything is calculated in your browser, with no network requests for conversions.

Explore more tools