Convert Epoch Time: The Complete Guide (Tools, Code, and Tips)

Introduction

If you need to convert epoch time for logs, APIs, or spreadsheets, you’re in the right place. This guide shows exactly how to convert epoch time to a readable date—and back again—using online tools, code snippets, terminal commands, and popular databases. You’ll also learn common pitfalls (like seconds vs. milliseconds) and how to avoid them.

Featured Snippet (Quick Answer)

Epoch time (Unix timestamp) counts seconds since 1970-01-01 00:00:00 UTC. To convert epoch time to a human-readable date, divide by 1000 if your value is in milliseconds, then format the date in UTC or your local time zone. Common methods: JavaScript new Date(epoch*1000), Python datetime.fromtimestamp(epoch, tz), and SQL to_timestamp(epoch) for seconds.

AI Overview

This guide explains epoch time, why it matters, and how to convert it reliably. Learn quick web, CLI, and spreadsheet methods; see code in JavaScript, Python, Java, Bash, SQL, and Go; and explore real use cases (APIs, logs, databases, IoT). You’ll avoid top mistakes (ms vs s, time zones, DST), follow best practices (UTC, ISO 8601), and find expert tips for performance and accuracy. Includes comparison tables, FAQs, and links to trusted documentation.

Key Takeaways

• Epoch time is the count of seconds since 1970-01-01 00:00:00 UTC.
• Values may be in seconds or milliseconds—identify this first.
• Converting is easy with online tools, code, spreadsheets, and SQL.
• Always clarify the time zone (UTC vs local) when formatting dates.
• Use ISO 8601 strings for clear, portable date-time values.
• Store timestamps as integers for performance; render as strings for users.

Table of Contents

• What is "convert epoch time"?
• Why it Matters
• Benefits
• How to Convert Epoch Time
• Step-by-Step Guide
• Real World Examples
• Common Mistakes
• Best Practices
• Expert Tips
• Comparison Table
• Frequently Asked Questions
• Internal Link Suggestions (ZenixTools)
• External References
• Conclusion
• Call To Action

What is "convert epoch time"?

“Convert epoch time” is a common phrase for turning a Unix timestamp (seconds since 1970-01-01 00:00:00 UTC) into a readable date, or converting a human date back to an epoch timestamp. You might also see related terms: Unix timestamp, epoch, POSIX time, or seconds since 1970.

Note: Some systems and APIs use milliseconds instead of seconds. That’s the #1 source of confusion when you convert epoch time.

Why it Matters

• Logs and metrics: Most observability tools store events as epoch timestamps.
• APIs and databases: Timestamps are compact and fast for sorting and indexing.
• Time zone safety: UTC-based storage avoids daylight saving issues in storage.
• Cross-language support: Every language and platform supports epoch time.
• Compliance and auditing: Precise, unambiguous timestamps are essential.

Benefits

• Speed: Integer comparisons and sorting are fast.
• Consistency: UTC epoch avoids locale mishaps in storage.
• Size: Smaller payloads than verbose date strings.
• Interoperability: A universal time unit used across systems.
• Clear math: Easy to add/subtract durations (e.g., now + 3600 for +1 hour).

How to Convert Epoch Time

Here’s the quick conversion cheat sheet for seconds-based epoch values:

• JavaScript (seconds to date): new Date(epochSeconds * 1000)
• JavaScript (milliseconds to date): new Date(epochMillis)
• Python (seconds to date): datetime.fromtimestamp(epoch, tz=timezone.utc)
• Python (to epoch seconds): int(dt.replace(tzinfo=timezone.utc).timestamp())
• Bash (seconds to date): date -u -d @1697040000
• SQL (PostgreSQL): to_timestamp(epoch_seconds)
• Excel: =((epochSeconds/86400) + DATE(1970,1,1)) with proper formatting

Tip: Always decide if your output should be in UTC or local time.

Step-by-Step Guide

1) Use an Online Tool (Fastest)

• Open ZenixTools’ Epoch Converter.
• Paste your timestamp.
• Select the unit (seconds or milliseconds).
• Choose output time zone: UTC or your local time.
• Copy the human-readable date, or convert a date back to epoch.

Note: Online tools are great for quick checks and debugging.

2) Convert in Your Browser Console (JavaScript)

• Open DevTools (F12) → Console.
• For seconds:

  const epochSeconds = 1697040000;
  const dt = new Date(epochSeconds * 1000);
  dt.toISOString(); // UTC ISO 8601
  dt.toString();    // Local time string
  

• For milliseconds:

  const epochMillis = 1697040000000;
  new Date(epochMillis).toISOString();
  

• Convert ISO date to epoch seconds:

  const iso = '2023-10-11T00:00:00Z';
  const epochSec = Math.floor(new Date(iso).getTime() / 1000);
  

Warning: JavaScript Date stores milliseconds since epoch. Be careful not to multiply by 1000 twice.

3) Python (Scripts and Data Science)

from datetime import datetime, timezone

# Epoch seconds to UTC datetime
epoch = 1697040000
utc_dt = datetime.fromtimestamp(epoch, tz=timezone.utc)
print(utc_dt.isoformat())  # 2023-10-11T00:00:00+00:00

# UTC datetime to epoch seconds
dt = datetime(2023, 10, 11, 0, 0, 0, tzinfo=timezone.utc)
print(int(dt.timestamp()))  # 1696982400 (example)

# If you have milliseconds
epoch_ms = 1697040000000
utc_dt_ms = datetime.fromtimestamp(epoch_ms / 1000, tz=timezone.utc)
print(utc_dt_ms.isoformat())

Tip: Always set tz=timezone.utc for consistent results.

4) Bash and Command Line

• Seconds to date (UTC):

  date -u -d @1697040000
  

• Seconds to date (local):

  date -d @1697040000
  

• ISO 8601 UTC:

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

• Now to epoch seconds:

  date +%s
  

• Convert readable date to epoch (UTC):

  date -u -d "2023-10-11 00:00:00" +%s
  

Note: BSD/macOS date uses different flags. On macOS:

# seconds to date (UTC)
date -u -r 1697040000
# date to epoch (UTC)
date -u -j -f "%Y-%m-%d %H:%M:%S" "2023-10-11 00:00:00" +%s

5) SQL Databases

• PostgreSQL:

  -- seconds to timestamp (with time zone awareness)
  SELECT to_timestamp(1697040000) AT TIME ZONE 'UTC';
  
  -- timestamp to epoch seconds
  SELECT EXTRACT(EPOCH FROM TIMESTAMPTZ '2023-10-11 00:00:00+00');
  

• MySQL/MariaDB:

  SELECT FROM_UNIXTIME(1697040000);              -- local time zone of server
  SELECT CONVERT_TZ(FROM_UNIXTIME(1697040000), '+00:00', '+00:00'); -- force UTC
  SELECT UNIX_TIMESTAMP('2023-10-11 00:00:00');   -- to epoch seconds
  

• SQLite:

  SELECT datetime(1697040000, 'unixepoch');              -- UTC by default
  SELECT strftime('%s', '2023-10-11 00:00:00');          -- to epoch seconds
  

Warning: Server time zones can affect outputs. Force UTC when consistency matters.

6) Java (Back-end Services)

import java.time.Instant;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;

long epochSeconds = 1697040000L;
Instant instant = Instant.ofEpochSecond(epochSeconds);
String isoUtc = DateTimeFormatter.ISO_INSTANT.format(instant); // 2023-10-11T00:00:00Z

// Epoch milliseconds to Instant
long epochMillis = 1697040000000L;
Instant i2 = Instant.ofEpochMilli(epochMillis);

// Instant to epoch seconds
long backToSeconds = instant.getEpochSecond();

7) Go (Services and CLI)

package main
import (
    "fmt"
    "time"
)

func main() {
    sec := int64(1697040000)
    t := time.Unix(sec, 0).UTC()
    fmt.Println(t.Format(time.RFC3339))

    // millis
    ms := int64(1697040000000)
    t2 := time.Unix(0, ms*int64(time.Millisecond)).UTC()
    fmt.Println(t2.Format(time.RFC3339))

    // back to epoch seconds
    fmt.Println(t.Unix())
}

8) Excel and Google Sheets

• Epoch seconds to date:
  • Formula: =((A2/86400) + DATE(1970,1,1))
  • Format the cell as Date/Time.
• Epoch milliseconds to date:
  • =((A2/1000)/86400 + DATE(1970,1,1))
• Date to epoch seconds (Google Sheets):
  • =INT((A2 - DATE(1970,1,1)) * 86400)

Tip: Excel stores dates as days since 1899-12-30; the division by 86400 converts seconds to days.

Real World Examples

1) API Payloads

• Input:

  { "created_at": 1697040000 }
  

• Processing (Python):

  dt = datetime.fromtimestamp(1697040000, tz=timezone.utc)
  print(dt.isoformat())  # 2023-10-11T00:00:00+00:00
  

• Output (for users): 2023-10-10 20:00:00 EDT (localized display)

2) Log Analysis

• You receive a log line with ts=1697040000000.
• Detect milliseconds: 13 digits → divide by 1000.
• Convert with Bash:

  date -u -d @$(echo 1697040000000/1000 | bc)
  

3) Database Migrations

• You’re moving from text timestamps to epoch.
• Strategy: Convert to UTC ISO 8601 for archival, store epoch seconds for indexing.
• PostgreSQL example:

  UPDATE events SET ts_epoch = EXTRACT(EPOCH FROM (ts AT TIME ZONE 'UTC'));
  CREATE INDEX idx_events_ts_epoch ON events (ts_epoch);
  

4) IoT Device Data

• Sensors send 32-bit epoch seconds.
• Beware Year 2038 on 32-bit devices.
• Mitigation: Use 64-bit integers and test rollover.

5) Scheduling and Reminders

• Store trigger time as epoch seconds.
• On execution, convert to local time for user-facing messages.
• Keep calculations in UTC to avoid DST pitfalls.

Common Mistakes

• Seconds vs. milliseconds: Treating milliseconds like seconds causes 1,000× errors.
• Time zone confusion: Formatting UTC as local (or vice versa) without labeling it.
• DST assumptions: Daylight saving is for display only; don’t shift stored UTC times.
• Server defaults: Relying on system time zone or locale without checking.
• 32-bit overflow: Legacy systems may fail around 2038-01-19.
• Ambiguous strings: Parsing “01/02/03” without a clear locale or format.
• Rounding errors: Floating math for timestamps; prefer integers.

Best Practices

• Store in UTC: Keep epoch timestamps in UTC for consistency.
• Use ISO 8601 for interchange: e.g., 2023-10-11T00:00:00Z.
• Log units: Clearly label “epoch_seconds” or “epoch_millis”.
• Validate input length: 10 digits (s), 13 digits (ms) as a quick heuristic.
• Prefer integers: Use 64-bit for durability.
• Document time zones: In APIs and databases, specify fields as UTC.
• Test DST boundaries: Especially for user displays and schedules.
• Keep libraries updated: Time zone databases change; update regularly.

Expert Tips

• Index performance: Integer epoch columns index well; filter with BETWEEN.
• BigInt in JS: For precise math with milliseconds, consider BigInt.
• Batch conversions: Vectorize in pandas, SQL, or streaming transforms.
• Monitoring: Include both an ISO 8601 string (for humans) and epoch (for machines) in logs.
• Serialization: Compress large time series by storing deltas from a base epoch.
• Validation gates: Reject timestamps outside plausible ranges to catch bad data early.

Comparison Table

Frequently Asked Questions

1. What is epoch time?

• Epoch time (Unix timestamp) is the number of seconds since 1970-01-01 00:00:00 UTC. It’s a compact, universal time format used in programming and databases.

2. Is my timestamp in seconds or milliseconds?

• A quick rule: 10 digits ≈ seconds; 13 digits ≈ milliseconds. Always check your API docs or field names for confirmation.

3. How do I convert epoch time in JavaScript?

• Seconds to date: new Date(s*1000). For milliseconds: new Date(ms). Use .toISOString() for UTC or .toString() for local time.

4. How do I convert epoch time in Python?

• Use datetime.fromtimestamp(s, tz=timezone.utc). To get epoch seconds back: int(dt.replace(tzinfo=timezone.utc).timestamp()).

5. How can I convert a readable date to epoch time?

• Use built-in functions: date -u -d "YYYY-MM-DD HH:MM:SS" +%s (GNU date), new Date(iso).getTime()/1000 (JS), or EXTRACT(EPOCH FROM timestamptz) (Postgres).

6. Why does my converted time look off by hours?

• It’s likely a time zone issue. You converted as UTC but displayed as local, or vice versa. Specify the time zone when formatting.

7. What is the difference between Unix time and POSIX time?

• They are closely related. POSIX time ignores leap seconds, treating each day as exactly 86,400 seconds. Most systems follow this behavior.

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

• Store timestamps in UTC. Apply time zone rules only when formatting for users. This avoids DST errors in calculations.

9. Will the Unix epoch ever change?

• No. The epoch (1970-01-01 00:00:00 UTC) is fixed. Systems may interpret or represent it differently, but the reference point remains the same.

10. What about the Year 2038 problem?

• 32-bit signed integers overflow on 2038-01-19. Use 64-bit integers (int64) to avoid this issue in modern systems.

11. How do I convert epoch time in SQL?

• PostgreSQL: to_timestamp(s)/EXTRACT(EPOCH...). MySQL: FROM_UNIXTIME/UNIX_TIMESTAMP. SQLite: datetime(..., 'unixepoch')/strftime('%s', ...).

12. How do I display ISO 8601?

• Use UTC with a trailing Z, e.g., 2023-10-11T00:00:00Z. In code, prefer toISOString (JS), isoformat (Python), or RFC3339/ISO_INSTANT (Go/Java).

13. Can epoch time represent dates before 1970?

• Yes, as negative seconds. Many systems support negative Unix timestamps for historical dates.

14. Why does Excel show a weird number?

• You must convert seconds to days: =(epoch/86400)+DATE(1970,1,1) and then format the cell as a Date/Time.

15. Should I store epoch in seconds or milliseconds?

• Use seconds for most use cases. Use milliseconds only if you need sub-second precision. Always document the unit in your schema.

Internal Link Suggestions (ZenixTools)

• ZenixTools Epoch Converter (Instantly convert epoch time to human-readable dates and back)
• Time Zone Converter (Compare UTC and local times across regions)
• ISO 8601 Date Formatter (Validate and format ISO date-time strings)
• Cron Expression Parser (Understand and test cron schedules)
• Timestamp Difference Calculator (Compute durations between two times)

External References

• MDN Web Docs: Date and time in JavaScript – https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Date
• Python Docs: datetime – https://docs.python.org/3/library/datetime.html
• Go time package – https://pkg.go.dev/time
• PostgreSQL to_timestamp/EXTRACT – https://www.postgresql.org/docs/current/functions-datetime.html
• SQLite date/time functions – https://sqlite.org/lang_datefunc.html
• MySQL/MariaDB date functions – https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html
• IANA Time Zone Database – https://www.iana.org/time-zones
• Google Search Central: Dates in structured data – https://developers.google.com/search/docs/appearance/structured-data/article#date-published
• Schema.org Date/DateTime – https://schema.org/DateTime

Conclusion

Converting epoch time is simple once you know your units (seconds vs. milliseconds) and your target time zone. Use UTC for storage, ISO 8601 for sharing, and human-friendly formats for display. With the tools and examples above, you can convert epoch time accurately across code, command line, and spreadsheets—without nasty time zone surprises.

Call To Action

Need a fast, accurate conversion right now? Try the ZenixTools Epoch Converter to convert epoch time to readable dates—and back—instantly. Save time, avoid mistakes, and keep your timestamps clean and consistent.