Convert Epoch Date: The Practical, Accurate Guide for Every Stack

Introduction

Epoch time (also called Unix time or POSIX time) is how computers track time: the seconds since 00:00:00 UTC on 1 January 1970. You’ll see it in logs, APIs, and databases. If you work with data, you’ll need to convert epoch date to a human-friendly format—and back—without breaking time zones or milliseconds.

Here’s exactly how to do it, fast and correctly.

Quick answer (Featured Snippet): To convert epoch date, first know whether the value is in seconds or milliseconds. For seconds, use a language’s fromtimestamp() or equivalent (e.g., new Date(epoch * 1000) in JavaScript). For milliseconds, pass the value directly (e.g., new Date(ms)). Always set or format in UTC or a known time zone, and output ISO 8601 when sharing.

AI Overview: Converting an epoch date means transforming a Unix timestamp (seconds or milliseconds since 1970-01-01T00:00:00Z) into a readable date-time and vice versa. Identify the unit (seconds vs. milliseconds). Use built-in functions: JavaScript new Date(), Python datetime.fromtimestamp(), SQL to_timestamp()/FROM_UNIXTIME(), Excel/Sheets conversion plus 25569 offset. Always handle UTC, time zones, and daylight saving carefully. Prefer ISO 8601 (e.g., 2026-08-13T12:34:56Z) for consistent sharing.

Key Takeaways

• Epoch time is seconds (or ms) since 1970-01-01T00:00:00Z.
• Know the unit: seconds vs. milliseconds is the #1 source of errors.
• Convert in UTC, then format into a local time zone if needed.
• Use ISO 8601 for storage and APIs.
• Validate ranges and watch for DST edge cases.
• ZenixTools can convert, format, and compare epoch timestamps quickly.

Table of Contents

• What is "convert epoch date"
• Why it Matters
• Benefits
• Step-by-Step Guide
• Real World Examples
• Common Mistakes
• Best Practices
• Expert Tips
• Comparison Table
• Frequently Asked Questions
• Conclusion
• Call To Action
• Internal Link Suggestions
• External References

What is "convert epoch date"

When people say “convert epoch date,” they mean translating a Unix timestamp into a readable date-time or the reverse.

• Epoch time: seconds since 1970-01-01T00:00:00Z (UTC).
• Some systems use milliseconds since epoch.
• Readable date-time: something like 2026-08-13 14:05:30 UTC or an ISO 8601 string: 2026-08-13T14:05:30Z.

Converting correctly requires:

• Recognizing seconds vs. milliseconds.
• Handling time zones (UTC vs. local offset).
• Formatting output for your audience or system.

Why it Matters

• Logs and metrics: Most platforms store times as epoch for speed.
• APIs and webhooks: Many payloads use epoch to avoid locale issues.
• Databases: Timestamps in epoch are compact and index-friendly.
• Analytics: Align events across services by converting to a single time standard.
• Compliance: Correct time handling affects audits and debugging.

Benefits

• Universal and unambiguous: Epoch avoids locale confusion.
• Performance: Numbers compare and sort faster than strings.
• Simplicity: Easy math for durations and intervals.
• Interoperability: Works across languages and systems.
• Storage efficiency: Smaller than full date strings.

Step-by-Step Guide

1) Identify your input unit

• If the value looks like 10–11 digits (e.g., 1699980000), it’s seconds.
• If it looks like 13 digits (e.g., 1699980000000), it’s milliseconds.
• If unsure, try both and see which makes sense in context.

Tip: Document the unit in code comments and API contracts.

2) Convert with an online tool (fastest)

• Paste your timestamp into ZenixTools Epoch Converter.
• Pick the input unit: seconds or milliseconds.
• Choose the output: local time, UTC, or a specific time zone.
• Copy as ISO 8601 for sharing or as a formatted string.

3) Command line (Linux/macOS)

• Seconds to readable (UTC):

date -u -d @1699980000

• Seconds to readable (local):

date -d @1699980000

• Milliseconds to readable:

ms=1699980000000; date -u -d @$(($ms/1000))

• Now to epoch seconds:

date +%s

• Format to ISO 8601 UTC:

date -u -d @1699980000 +"%Y-%m-%dT%H:%M:%SZ"

Note: BSD/macOS date uses slightly different flags. Portable approach:

python3 - <<'PY'
import datetime,sys
print(datetime.datetime.utcfromtimestamp(1699980000).isoformat()+"Z")
PY

4) PowerShell (Windows)

• Seconds to readable (UTC):

$epoch=1699980000
(Get-Date 01/01/1970 -UFormat %s) | Out-Null
[DateTimeOffset]::FromUnixTimeSeconds($epoch).UtcDateTime

• Milliseconds:

[DateTimeOffset]::FromUnixTimeMilliseconds(1699980000000).UtcDateTime

• Current time to epoch seconds:

[DateTimeOffset]::UtcNow.ToUnixTimeSeconds()

5) JavaScript / TypeScript

• Seconds to Date:

const s = 1699980000;
const d = new Date(s * 1000); // local time zone by default

• Milliseconds to Date:

const ms = 1699980000000;
const d = new Date(ms);

• Format as ISO 8601 UTC:

const iso = d.toISOString(); // e.g., 2026-11-14T10:00:00.000Z

• Get epoch from Date:

const epochMs = d.getTime();     // milliseconds
const epochS  = Math.floor(d.getTime()/1000); // seconds

• Convert to a specific time zone without changing the moment:

const fmt = new Intl.DateTimeFormat('en-US', {
  timeZone: 'America/Los_Angeles',
  year: 'numeric', month: '2-digit', day: '2-digit',
  hour: '2-digit', minute: '2-digit', second: '2-digit'
}).format(d);

6) Python

• Seconds to readable (local vs UTC):

import datetime as dt
s = 1699980000
print(dt.datetime.fromtimestamp(s))             # local
print(dt.datetime.utcfromtimestamp(s))          # UTC (naive)
print(dt.datetime.fromtimestamp(s, dt.timezone.utc))  # aware UTC

• Milliseconds:

ms = 1699980000000
print(dt.datetime.fromtimestamp(ms/1000, dt.timezone.utc))

• Current time to epoch:

now = dt.datetime.now(dt.timezone.utc)
epoch_s = int(now.timestamp())
epoch_ms = int(now.timestamp() * 1000)

• ISO 8601 formatting:

now.isoformat().replace('+00:00','Z')

7) Java

• Seconds to Instant and ZonedDateTime:

long s = 1699980000L;
java.time.Instant instant = java.time.Instant.ofEpochSecond(s);
java.time.ZonedDateTime utc = instant.atZone(java.time.ZoneOffset.UTC);

• Milliseconds:

long ms = 1699980000000L;
Instant instant = Instant.ofEpochMilli(ms);

• Format ISO 8601:

String iso = java.time.format.DateTimeFormatter.ISO_INSTANT.format(instant);

• Current time to epoch:

long nowS  = Instant.now().getEpochSecond();
long nowMs = Instant.now().toEpochMilli();

8) SQL

• PostgreSQL:

-- seconds to timestamp (UTC by default)
SELECT to_timestamp(1699980000) AT TIME ZONE 'UTC';

-- milliseconds
SELECT to_timestamp(1699980000000 / 1000.0) AT TIME ZONE 'UTC';

-- timestamp to epoch seconds
SELECT EXTRACT(EPOCH FROM TIMESTAMP '2026-11-14 10:00:00+00');

• MySQL / MariaDB:

-- seconds to datetime
SELECT FROM_UNIXTIME(1699980000);

-- milliseconds to datetime
SELECT FROM_UNIXTIME(1699980000000/1000);

-- datetime to epoch seconds
SELECT UNIX_TIMESTAMP('2026-11-14 10:00:00');

• BigQuery:

-- seconds to timestamp
SELECT TIMESTAMP_SECONDS(1699980000);

-- milliseconds to timestamp
SELECT TIMESTAMP_MILLIS(1699980000000);

-- timestamp to epoch
SELECT UNIX_SECONDS(TIMESTAMP '2026-11-14 10:00:00+00');

9) Excel and Google Sheets

• Excel stores days since 1899-12-30. UTC conversions need care.

Seconds to Excel date (in days):

= (A2 / 86400) + 25569

Where A2 has epoch seconds. Format the cell as date/time.

Milliseconds:

= (A2 / 1000 / 86400) + 25569

Convert Excel date back to epoch seconds:

= (A2 - 25569) * 86400

Note: Excel applies your local time zone when formatting. For UTC-only, keep as value and label as UTC, or use Power Query/Office Scripts.

10) Time zones and DST

• Convert in UTC first. Then display in the target zone.
• DST shifts cause 23- or 25-hour days and repeated times.
• Use IANA zone names (e.g., America/Los_Angeles) for accuracy.

Example (Python zone conversion):

from zoneinfo import ZoneInfo
import datetime as dt
s = 1699980000
utc = dt.datetime.fromtimestamp(s, dt.timezone.utc)
pst = utc.astimezone(ZoneInfo('America/Los_Angeles'))

11) Validate and sanity-check

• Verify range: realistic timestamps fall between 0 and ~4102444800 (year 2100) for many apps.
• Cross-check by converting both directions.
• Compare multiple tools if something looks wrong.

Real World Examples

• Server logs: Nginx, Apache, and cloud logs often use epoch. Convert to align incidents.
• JWT tokens: iat/exp are epoch seconds. Confirm token windows.
• Analytics events: Many CDPs export epoch. Normalize to UTC for dashboards.
• Databases: Store epoch for fast sorting; convert on output.
• Finance: Trade stamps from feeds in epoch require exact time zone handling.
• IoT/Telemetry: Devices send compact epoch values over low-bandwidth links.
• Blockchain: Blocks and transactions reference epoch-like times in explorers.

Common Mistakes

• Mixing seconds and milliseconds, causing dates decades off.
• Formatting in local time when the API expects UTC.
• Ignoring DST, leading to shifted or duplicated hours.
• Truncating instead of rounding when converting ms to s.
• Assuming system locale/offset instead of setting a zone explicitly.
• Dropping timezone info from ISO strings, creating ambiguity.
• Using 32-bit integers that overflow future dates.
• Misreading 0 as null; 0 is 1970-01-01T00:00:00Z.

Best Practices

• Store in UTC; convert to local only for display.
• Prefer ISO 8601 with Z or explicit offset, e.g., 2026-08-13T12:34:56Z.
• Always document units (s vs ms) in code and API specs.
• Use time-zone-aware types (e.g., Python aware datetimes, Java ZonedDateTime).
• Validate input ranges; reject impossible timestamps.
• Use IANA time zone IDs, not ambiguous abbreviations.
• Keep systems time-synced (NTP) to avoid drift.
• Write repeatable tests around DST boundaries.

Expert Tips

• When logs disagree, normalize everything to UTC ISO strings for diffing.
• Use monotonic clocks for durations; epoch for absolute times.
• For round-trips, avoid loss: keep milliseconds when important.
• In SQL, store both raw epoch and a generated timestamp for querying.
• Label charts with time zone context to avoid misreads.
• For public APIs, include both epoch and ISO 8601 fields for convenience.
• Validate with two libraries to catch platform quirks.

Comparison Table

Frequently Asked Questions

1. What is epoch time?

• Epoch time counts seconds since 1970-01-01T00:00:00Z (UTC). It’s a simple, universal way to represent time.

2. How do I convert epoch date in JavaScript?

• For seconds: new Date(s * 1000). For milliseconds: new Date(ms). Use toISOString() for UTC output.

3. How do I convert epoch date in Python?

• Use datetime.fromtimestamp(seconds, timezone.utc) or fromtimestamp(ms/1000, timezone.utc). Format with .isoformat().

4. What’s the difference between seconds and milliseconds?

• Seconds have ~10 digits; milliseconds have ~13. Mixing them is the top cause of wrong dates.

5. Why is my converted time off by hours?

• You likely used local time instead of UTC, or applied the wrong time zone.

6. How do I convert to a specific time zone?

• Convert to UTC first, then apply a zone (e.g., ZoneInfo in Python, Intl.DateTimeFormat in JS).

7. Can I get epoch from a date?

• Yes. JS: Math.floor(date.getTime()/1000). Python: int(dt.timestamp()). Java: Instant.getEpochSecond().

8. How do I handle daylight saving time (DST)?

• Use IANA zones and timezone-aware types. Test around DST transitions.

9. Why do some systems use milliseconds?

• Milliseconds provide finer precision for logs and events. APIs should state the unit.

10. How do I convert epoch in SQL?

• PostgreSQL: to_timestamp(s). MySQL: FROM_UNIXTIME(s). For ms, divide by 1000 first.

11. How do I convert in Excel or Sheets?

• Use (epoch/86400)+25569 for seconds. Format as date/time. Remember the displayed time uses your local zone.

12. What about negative timestamps (before 1970)?

• Many systems support them. Test your stack; some databases and Windows tools handle them differently.

13. Should I store ISO 8601 or epoch?

• Store epoch for performance and ISO 8601 for clarity—or both. Always keep UTC.

14. How do I validate a timestamp?

• Check digit length (s vs ms), range (e.g., 0–4102444800 for near-term), and that it round-trips correctly.

15. Is Unix epoch the same as Java epoch?

• Yes, both start at 1970-01-01T00:00:00Z. Java often uses milliseconds; watch the unit.

Conclusion

To convert epoch date reliably, always confirm the unit, work in UTC, and output ISO 8601. Use built-in functions in your language, or a quick utility like ZenixTools for instant checks. Handle time zones intentionally, test around DST, and document your choices. With these habits, your timestamps will be accurate, portable, and easy to debug.

Call To Action

Need a fast, correct conversion? Paste your timestamp into the ZenixTools Epoch Converter. Toggle seconds or milliseconds, switch zones, and copy an ISO 8601 string in seconds. Stop guessing; ship accurate time data today.

Internal Link Suggestions

• ZenixTools Epoch & Timestamp Converter
• ZenixTools Time Zone Converter (UTC, IANA zones, DST-safe)
• ZenixTools ISO 8601 Date Formatter & Validator
• ZenixTools Date Difference & Duration Calculator
• ZenixTools Cron Expression Parser & Next Run Viewer

External References

• MDN Web Docs: Date and time — https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Date
• MDN Web Docs: Intl.DateTimeFormat — https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat
• Python Docs: datetime — https://docs.python.org/3/library/datetime.html
• PostgreSQL: Date/Time Functions — https://www.postgresql.org/docs/current/functions-datetime.html
• MySQL: Date and Time Functions — https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html
• W3C: Date and Time formats (ISO 8601) — https://www.w3.org/TR/NOTE-datetime
• Schema.org: Date and DateTime — https://schema.org/DateTime
• Google Search Central: Structured data guidelines — https://developers.google.com/search/docs/appearance/structured-data/intro-structured-data