Epoch Mili: The Complete Guide to Milliseconds Since 1970

Introduction

If you work with logs, APIs, or databases, you’ve seen timestamps like 1698796800000. That number is epoch mili: time measured in milliseconds since January 1, 1970 (UTC). This guide explains what it means, why it matters, and how to convert it cleanly across languages and systems—without time zone pitfalls.

Quick Answer (Featured Snippet)

Epoch mili is a Unix timestamp expressed in milliseconds since January 1, 1970, 00:00:00 UTC. To convert epoch mili to a date, divide by 1000 to get seconds if needed and format in UTC or a target time zone. For example, in JavaScript: new Date(1698796800000). Use epoch mili for precise event timing, sorting, and cross-system consistency.

Key Takeaways

• Epoch mili = milliseconds since 1970-01-01T00:00:00Z.
• It’s ideal for precise ordering and cross-language consistency.
• Beware of mixing seconds (10 digits) with milliseconds (13 digits).
• Store timestamps in UTC; convert to local time only for display.
• Use built-in language functions to convert reliably.
• Prefer ISO 8601/RFC 3339 strings at external interfaces.
• Validate ranges and types to avoid overflow and off-by-1000 errors.

AI Overview

Epoch mili represents time in milliseconds since the Unix epoch (January 1, 1970 UTC). It’s common in logging, analytics, APIs, and databases because it’s numeric, sortable, and time zone–neutral. Convert with built-in functions (for example, JavaScript Date, Python datetime) and always confirm whether your system expects seconds or milliseconds. Store UTC internally, use ISO 8601 for APIs, and apply local time zones only for presentation.

Table of Contents

• What is epoch mili
• 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 epoch mili

Epoch mili is a Unix timestamp measured in milliseconds since the Unix epoch: 1970-01-01T00:00:00Z. One second equals 1,000 milliseconds, so epoch in seconds (commonly 10 digits) becomes epoch mili by multiplying by 1,000 (commonly 13 digits).

Notes:

• Epoch mili is always based on UTC.
• It doesn’t include time zone or calendar formatting; it’s a pure number.
• It’s ideal for precise timing, sorting, and storage.

Related terms (used naturally throughout): epoch time, Unix timestamp, milliseconds since 1970, POSIX time, UTC time, epoch ms, timestamp converter, ISO 8601, RFC 3339.

Why it Matters

• Cross-language standard: Every major language supports Unix time.
• Sorting and comparisons: Numeric values are easy to sort and index.
• Precision: Milliseconds provide finer granularity than seconds.
• Simplicity: No time zone handling until you present data.
• Interoperability: Many logs, metrics, and APIs use epoch mili.

Benefits

• Precision to the millisecond for events and telemetry.
• Compact numeric storage suited for databases and caches.
• Deterministic ordering across systems.
• Faster comparisons than parsing date strings.
• Easy math for durations and windows (differences of two numbers).

Step-by-Step Guide

Follow these steps to convert epoch mili to human-readable time and back.

1) Identify the unit: seconds or milliseconds

• Seconds are usually 10 digits: 1698796800.
• Milliseconds are usually 13 digits: 1698796800000.
• When unsure, check documentation or test a small sample.

2) Convert epoch mili to a date

• If you have milliseconds, use APIs that accept milliseconds.
• If your API expects seconds, divide by 1000 first (integer division).

Examples:

JavaScript

// From epoch mili to Date
const ms = 1698796800000;
const date = new Date(ms); // Local time object
const iso = new Date(ms).toISOString(); // UTC ISO 8601 string

// From Date to epoch mili
const nowMs = Date.now(); // milliseconds since 1970
const fromDateMs = new Date().getTime();

Node.js (with timezone formatting via Intl)

const ms = 1698796800000;
const fmt = new Intl.DateTimeFormat('en-US', { timeZone: 'UTC', dateStyle: 'full', timeStyle: 'long' });
console.log(fmt.format(new Date(ms)));

Python

from datetime import datetime, timezone

ms = 1698796800000
# Epoch mili to datetime (UTC)
dt_utc = datetime.fromtimestamp(ms / 1000, tz=timezone.utc)
iso = dt_utc.isoformat()  # 'YYYY-MM-DDTHH:MM:SS.mmm+00:00'

# Datetime to epoch mili (UTC)
now_ms = int(datetime.now(tz=timezone.utc).timestamp() * 1000)

Java

import java.time.*;

long ms = 1698796800000L;
Instant instant = Instant.ofEpochMilli(ms);
ZonedDateTime utc = instant.atZone(ZoneId.of("UTC"));
String iso = utc.toOffsetDateTime().toString();

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

SQL (PostgreSQL)

-- Epoch mili to timestamp (UTC)
SELECT to_timestamp(1698796800000 / 1000.0) AT TIME ZONE 'UTC';

-- timestamp to epoch mili
SELECT (extract(epoch FROM now()) * 1000)::bigint AS epoch_mili_now;

MySQL

-- Epoch mili to datetime (UTC display)
SELECT FROM_UNIXTIME(1698796800000 / 1000);

-- datetime to epoch mili
SELECT FLOOR(UNIX_TIMESTAMP(CURRENT_TIMESTAMP(3)) * 1000) AS epoch_mili_now;

Go

package main
import (
  "fmt"
  "time"
)
func main() {
  ms := int64(1698796800000)
  t := time.Unix(0, ms*int64(time.Millisecond)) // UTC
  fmt.Println(t.UTC().Format(time.RFC3339Nano))

  nowMs := time.Now().UnixNano() / int64(time.Millisecond)
  fmt.Println(nowMs)
}

Bash (GNU date)

# Epoch mili to human-readable (UTC)
date -u -d @$(echo "1698796800000/1000" | bc)

# Now to epoch mili (Linux)
python3 - <<'PY'
import time
print(int(time.time()*1000))
PY

3) Handle time zones deliberately

• Store in UTC internally.
• Convert to a user’s time zone only when displaying.
• Use IANA time zones (e.g., America/New_York) for correctness.

JavaScript example

const ms = 1698796800000;
const ny = new Intl.DateTimeFormat('en-US', { timeZone: 'America/New_York', dateStyle: 'medium', timeStyle: 'short' }).format(new Date(ms));

4) Validate types and ranges

• Use 64-bit integers for epoch mili.
• Check for nulls, strings, and out-of-range values.
• In JSON, send as number when possible; if very large, consider string to avoid precision loss.

5) Round or truncate with intent

• Truncate to seconds: Math.floor(ms / 1000).
• Keep milliseconds: avoid unnecessary rounding.

Real World Examples

• Logging and APM: Order events and compute latencies using epoch mili.
• Analytics: Window functions (e.g., last 15 minutes = nowMs - 900000).
• Databases: Bigint columns for compact, sortable time values.
• IoT and telemetry: Millisecond precision across devices and gateways.
• Caching and TTLs: Compute expirations with nowMs + durationMs.
• Scheduling: Convert cron outputs to timestamps for exact triggers.
• Payments and fraud: Sequence events to detect anomalies reliably.

Example: Calculate a 7-day retention window in JavaScript

const DAY = 24 * 60 * 60 * 1000;
const cutoff = Date.now() - 7 * DAY; // keep events with timestamp >= cutoff

Example: Partition data by day in SQL (PostgreSQL)

-- Extract the UTC date from epoch mili for partition routing
SELECT (to_timestamp(ts_ms/1000.0) AT TIME ZONE 'UTC')::date AS utc_day
FROM events;

Common Mistakes

• Mixing seconds and milliseconds: 1000x errors are common. Check digit length.
• Time zone confusion: Storing local times; always store UTC.
• DST surprises: Display in local zones only; store/compute in UTC.
• Integer overflow: Using 32-bit ints; use 64-bit or BigInt.
• String vs number: JSON parsers may coerce; validate schemas.
• Parsing ISO as local: Prefer explicit UTC or time zone offset.
• Rounding drift: Repeated rounding leads to errors; convert once.

Best Practices

• Store UTC in epoch mili; present in local time with IANA zones.
• Use ISO 8601/RFC 3339 strings at public API boundaries.
• Keep milliseconds inside the system for precision and sorting.
• Validate inputs: type, length (10 vs 13 digits), numeric range.
• Document time expectations in API specs and database schemas.
• Index timestamp columns for fast range queries.
• Use monotonic clocks for durations; wall clock for absolute time.
• Add observability: log both epoch mili and ISO strings when debugging.

Expert Tips

• JavaScript precision: Number is a 53-bit float; use BigInt for future-proofing if needed, or handle as strings in JSON for very large values.
• Database storage: Prefer BIGINT; in PostgreSQL, consider timestamptz for human queries and a mirror BIGINT for pipelines.
• Compression: Delta-encode epoch mili in columnar stores to improve compression.
• Partitioning: Partition large tables by day derived from epoch mili.
• Time sync: Use NTP/chrony to keep system clocks accurate.
• Boundary tests: Validate leap seconds handling in your stack (most systems smear or ignore); trust platform defaults and test.
• Performance: Sorting numeric timestamps is cheaper than parsing strings in hot paths.

Comparison Table

Units and Precision

Language Support

Frequently Asked Questions

1. What does epoch mili mean?

• It means milliseconds since 1970-01-01 00:00:00 UTC, often used for precise timestamps.

2. Is epoch mili the same as Unix time?

• Unix time is commonly in seconds. Epoch mili is Unix time in milliseconds.

3. How do I tell if a timestamp is seconds or milliseconds?

• Check the digit length: seconds ~10 digits; milliseconds ~13 digits. Or try dividing by 1000 and see if the date is plausible.

4. How do I convert epoch mili to a date in JavaScript?

• Use new Date(ms) or new Date(ms).toISOString() for UTC.

5. How do I convert a Python datetime to epoch mili?

• int(datetime.now(timezone.utc).timestamp() * 1000).

6. Why do my timestamps look shifted by hours?

• You’re seeing local time vs UTC. Store UTC and convert on display.

7. Can epoch mili handle time zones?

• No. It’s a pure UTC-based number. Apply time zones only when formatting.

8. Will epoch mili overflow?

• Use 64-bit integers. Most modern systems safely handle epoch mili well past 2100.

9. Should APIs return ISO 8601 or epoch mili?

• Prefer ISO 8601/RFC 3339 for readability. Provide epoch mili in data-heavy or performance-critical endpoints.

10. How do I index epoch mili in databases?

• Use BIGINT with a B-tree index. Consider partitioning by date for large tables.

11. What about leap seconds?

• Most systems smear or ignore them. Trust platform defaults and test conversions end-to-end.

12. Why do I see 13-digit vs 10-digit timestamps?

• 13 digits are milliseconds; 10 digits are seconds. Multiply or divide by 1000 as needed.

13. How do I get the current epoch mili in Go?

• time.Now().UnixMilli() (Go 1.17+), or time.Now().UnixNano()/1e6.

14. Is epoch mili better than ISO strings for storage?

• For sorting and compactness, yes. For readability and interchange, ISO is better. Many systems store both.

15. How can I avoid off-by-1000 bugs?

• Document expected units, validate inputs, assert digit length, and add tests that fail on mismatched units.

Conclusion

Epoch mili is a precise, portable way to represent time in milliseconds since 1970-01-01 UTC. Use it for ordering, analytics, and storage, then convert to human-readable formats for users. By handling units, time zones, and types with care, you can make epoch mili the backbone of reliable, scalable time workflows.

Call To Action

Ready to work faster with time? Try ZenixTools to convert epoch mili to readable dates, generate ISO 8601 strings, and debug time zone issues. Build cleaner pipelines with confidence.

Internal Link Suggestions

• ZenixTools Unix Timestamp Converter
• ZenixTools ISO 8601/RFC 3339 Date Formatter
• ZenixTools Time Zone Converter
• ZenixTools Cron Expression Parser and Next Run Calculator
• ZenixTools Date Math Playground (Durations, Windows, Offsets)

External References

• Google Search Central: https://developers.google.com/search
• MDN Web Docs (Date): https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date
• W3C (Time and Dates reference via HTML spec): https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#dates-and-times
• IETF RFC 3339 (Date and Time on the Internet): https://www.rfc-editor.org/rfc/rfc3339
• Schema.org (Date/Time types): https://schema.org/DateTime