Epoch & Unix Timestamp Converter

Paste a unix epoch — seconds, milliseconds or microseconds are detected automatically — and get the UTC, ISO 8601 and local time instantly, or type a date to get its epoch back. Below the converter you get copy-ready SQL for the database side: PostgreSQL to_timestamp() for epoch-to-timestamptz, extract(epoch FROM ...) for the reverse, range filters on bigint epoch columns, a generated column that exposes epoch storage as a real timestamptz, and the MySQL equivalents. Everything runs in your browser.

Unix epoch (s / ms / µs auto-detected)

Epoch → date

Detected unit : seconds
UTC           : 2023-11-14 22:13:20 UTC
ISO 8601      : 2023-11-14T22:13:20.000Z
Local         : (shown after page loads)

Seconds       : 1700000000
Milliseconds  : 1700000000000
Microseconds  : 1700000000000000

Date / time (bare values read as UTC)

Date → epoch

Interpreted as: 2026-08-29T12:00:00.000Z

Epoch seconds : 1788004800
Epoch ms      : 1788004800000

PostgreSQL / MySQL snippets

-- Epoch seconds → timestamptz
SELECT to_timestamp(1700000000);                          -- 1-arg form takes double precision seconds
SELECT to_timestamp(1700000000) AT TIME ZONE 'UTC';       -- as timestamp (no tz) in UTC

-- Epoch milliseconds → timestamptz
SELECT to_timestamp(1700000000000 / 1000.0);

-- timestamp → epoch seconds / milliseconds
SELECT extract(epoch FROM now())::bigint            AS epoch_s;
SELECT (extract(epoch FROM now()) * 1000)::bigint   AS epoch_ms;
SELECT extract(epoch FROM timestamptz '2026-08-29 12:00:00+00')::bigint;

-- Filter a bigint epoch column against a date range
SELECT *
FROM   events
WHERE  created_epoch >= extract(epoch FROM date '2026-08-01')::bigint
AND    created_epoch <  extract(epoch FROM date '2026-09-01')::bigint;

-- Generated column: keep epoch storage, query as timestamptz
ALTER TABLE events
  ADD COLUMN created_at timestamptz
  GENERATED ALWAYS AS (to_timestamp(created_epoch)) STORED;

-- MySQL equivalents
-- SELECT FROM_UNIXTIME(1700000000);
-- SELECT UNIX_TIMESTAMP('2026-08-29 12:00:00');

Notes

• to_timestamp(double precision) returns timestamptz. Displayed value depends on your session TimeZone setting; the stored instant is the same.
• extract(epoch FROM ts) returns numeric with fractional seconds — cast to ::bigint for whole seconds.
• For a timestamp WITHOUT time zone column, extract(epoch FROM ts) treats the value as your session time zone when converting; use ts AT TIME ZONE 'UTC' first if the column stores UTC.
• 13-digit values are milliseconds (JavaScript Date.now()), 16-digit are microseconds (PostgreSQL internal); divide before calling to_timestamp().

Do more than epoch & unix timestamp converter — meet Chat2DB

Chat2DB is an AI-powered SQL client for Windows, macOS and Linux. Write SQL in natural language, format and optimize queries automatically, and manage MySQL, PostgreSQL, Oracle and 20+ other databases in one workspace.

How to use

Paste an epoch value (e.g. 1700000000 or 1700000000000) — the unit is detected from its length and converted to UTC, ISO 8601 and your local time.
Or enter a date like 2026-08-29 12:00:00 (interpreted as UTC) to get epoch seconds and milliseconds back.
Copy the generated PostgreSQL / MySQL snippets to do the same conversion in SQL.

Frequently asked questions

How do I convert an epoch to a timestamp in PostgreSQL?

Use to_timestamp(): SELECT to_timestamp(1700000000) returns a timestamptz. The argument is double precision seconds, so pass milliseconds as to_timestamp(ms / 1000.0). To see the result in a fixed zone regardless of session settings, append AT TIME ZONE 'UTC', which yields a plain timestamp in UTC.

How do I get the unix timestamp from a date in PostgreSQL?

Use extract: SELECT extract(epoch FROM now())::bigint returns epoch seconds, and (extract(epoch FROM now()) * 1000)::bigint returns milliseconds. extract(epoch FROM ...) works on timestamp, timestamptz, date and interval values; for an interval it returns the total number of seconds in the interval.

Should I store timestamps as bigint epoch or timestamptz?

Prefer timestamptz: it is the same 8 bytes as bigint, is human-readable in every query, works with date arithmetic, intervals and time zone conversion, and indexes just as well. Use bigint epoch only when an external system dictates it — and consider a stored generated column with to_timestamp() so queries stay readable. To explore either format against a live database with AI-assisted SQL, try Chat2DB: download at https://chat2db.ai/download or use https://app.chat2db.ai.