Unix timestamps are everywhere in software development. Every API response, every database record, every log file uses them. But the raw number — something like 1715000000 — is meaningless to a human. You need to convert it to understand when something actually happened.
That is exactly why we built our free Timestamp Converter. Enter any Unix timestamp and get a human-readable date instantly. Or go the other direction: type a date, get the timestamp. All processing happens in your browser — no data sent to any server, no signup required.
What Is a Unix Timestamp?
A Unix timestamp (also called epoch time, POSIX time, or Unix epoch) is the number of seconds that have elapsed since January 1, 1970, 00:00:00 UTC — excluding leap seconds. It is a single, monotonically increasing number that represents a specific moment in time.
For example:
| Unix Timestamp | Human-Readable Date (UTC) |
|---|---|
0 | January 1, 1970 00:00:00 |
86400 | January 2, 1970 00:00:00 |
946684800 | January 1, 2000 00:00:00 (Y2K) |
1609459200 | January 1, 2021 00:00:00 |
1715000000 | May 6, 2024 16:53:20 |
2147483647 | January 19, 2038 03:14:07 (Year 2038 problem!) |
The timestamp is always in UTC, regardless of your local timezone. This is one of its greatest advantages: a single number that means the same thing everywhere in the world.
Why You Need a Timestamp Converter
Developers encounter Unix timestamps constantly:
- API responses: REST APIs and GraphQL return timestamps as integers. When debugging, you need to know what time they represent.
- Database records:
created_atandupdated_atfields are often stored as Unix timestamps. Querying logs means translating these numbers. - Log files: Server logs, application logs, and access logs all use timestamp formats that may need conversion.
- Cookies and sessions: Expiration times are stored as Unix timestamps.
- Certificates: SSL/TLS certificate validity periods use Unix timestamps for
notBeforeandnotAfter. - Cron jobs: Next-run calculations and scheduling systems output timestamps.
Without a converter, you have to mentally translate a number like 1746633193 — which is nearly impossible. A good converter shows you the date in multiple formats instantly.
Unix Timestamps vs Milliseconds: The Common Gotcha
One of the most frequent mistakes when working with timestamps is confusing seconds with milliseconds.
Unix timestamps are traditionally in seconds. But JavaScript's Date.now() and many modern APIs return milliseconds. The difference is a factor of 1,000 — and getting it wrong means your date is off by a factor of 1,000 as well.
| Format | Example | Represents |
|---|---|---|
| Seconds | 1715000000 | May 6, 2024 |
| Milliseconds | 1715000000000 | May 6, 2024 (same moment) |
Our Timestamp Converter auto-detects the format. If the number is larger than 1 trillion (10^12), it assumes milliseconds and converts accordingly. You do not need to worry about the distinction.
How to Convert a Unix Timestamp
Method 1: Using Our Free Timestamp Converter
The easiest approach: open the Timestamp Converter, paste any Unix timestamp, and get results in multiple formats:
- Unix timestamp (seconds)
- Unix timestamp (milliseconds)
- ISO 8601 format
- RFC 2822 / UTC string
- Local time representation
- RFC 3339 format
Every value has a copy button for quick pasting into your code or terminal.
Method 2: Command Line (Linux/macOS)
If you have access to a Unix shell, you can convert timestamps directly:
# Timestamp to human-readable (GNU date)
date -d @1715000000
# Output: Mon May 6 16:53:20 UTC 2024
# On macOS (BSD date):
date -r 1715000000
# Current timestamp:
date +%s
# Output: 1746633193Method 3: JavaScript
// Unix timestamp (seconds) to Date
const date = new Date(1715000000 * 1000);
console.log(date.toISOString());
// "2024-05-06T16:53:20.000Z"
// Date to Unix timestamp
const now = new Date();
const timestamp = Math.floor(now.getTime() / 1000);
console.log(timestamp);
// 1746633193 (or whatever the current time is)Method 4: Python
from datetime import datetime, timezone
# Unix timestamp to datetime
dt = datetime.fromtimestamp(1715000000, tz=timezone.utc)
print(dt.isoformat())
# 2024-05-06T16:53:20+00:00
# Datetime to Unix timestamp
timestamp = int(datetime.now(timezone.utc).timestamp())
print(timestamp)
# 1746633193Method 5: Go
import (
"fmt"
"time"
)
// Unix timestamp to time.Time
t := time.Unix(1715000000, 0).UTC()
fmt.Println(t.Format(time.RFC3339))
// 2024-05-06T16:53:20Z
// time.Time to Unix timestamp
ts := time.Now().Unix()
fmt.Println(ts)Timestamp Formats Explained
ISO 8601
The international standard for date and time representation. Format: YYYY-MM-DDTHH:MM:SS.sssZ. Example: 2024-05-06T16:53:20.000Z. The T separates date from time, and the Z indicates UTC.
ISO 8601 is the recommended format for APIs, databases, and data interchange because it is unambiguous and sortable.
RFC 2822
The format used in email headers and HTTP responses. Example: Mon, 06 May 2024 16:53:20 GMT. More human-readable than ISO 8601 but less machine-friendly.
RFC 3339
A profile of ISO 8601 that specifies timezone offsets explicitly. Example: 2024-05-06T12:53:20-04:00. Commonly used in API specifications and configuration files.
Relative Time Calculator
Sometimes you need to know: "What was the timestamp 3 days ago?" or "What date is 2 weeks from now?"
Our Timestamp Converter includes a relative time calculator. Enter natural language expressions like:
3 days ago2 hours from now+30 minutes-1 week6 months from now
And get the exact Unix timestamp and all date formats for that moment. This is incredibly useful for:
- Setting up monitoring: "I need to check everything since 7 days ago" — get the exact timestamp for your query.
- API date ranges: Many APIs require
fromandtoparameters as Unix timestamps. - Scheduling calculations: "What timestamp corresponds to 2 weeks before the deadline?"
- Log queries: ElasticSearch, Splunk, and other log platforms accept Unix timestamps for time-range filters.
The Year 2038 Problem
One timestamp-related date you should know about: January 19, 2038, 03:14:07 UTC. This corresponds to the Unix timestamp 2147483647 — which is the maximum value of a signed 32-bit integer.
One second later, the timestamp would be 2147483648, which overflows a 32-bit signed integer and becomes -2147483648 — equivalent to December 13, 1901. Systems that still use 32-bit timestamps will experience catastrophic date calculation errors.
Most modern systems have migrated to 64-bit timestamps (which can represent dates for approximately 292 billion years), but embedded systems, older databases, and legacy file formats may still be vulnerable. If your software handles timestamps, verify that it uses 64-bit integers.
Unix Timestamp Cheat Sheet
| Duration | In Seconds |
|---|---|
| 1 minute | 60 |
| 1 hour | 3,600 |
| 1 day | 86,400 |
| 1 week | 604,800 |
| 1 month (average) | 2,629,746 |
| 1 year (non-leap) | 31,536,000 |
Timezone Awareness
Unix timestamps are always in UTC. They do not encode timezone information. When you convert a timestamp to a human-readable date, the result depends on your timezone:
Timestamp: 1715000000
UTC: Mon, 06 May 2024 16:53:20 GMT
EST (UTC-5): Mon, 06 May 2024 11:53:20 EST
CST (UTC+8): Tue, 07 May 2024 00:53:20 CST
JST (UTC+9): Tue, 07 May 2024 01:53:20 JSTThis is why the same timestamp can appear as different dates depending on where you are in the world. The timestamp itself never changes — only its human-readable representation does.
Our Timestamp Converter shows results in both UTC and your local timezone, so you can see the difference clearly.
Use Cases for Timestamp Conversion
- API debugging: Paste the
created_atfield from a JSON response to understand when a resource was created. - Database queries: Convert a date range to Unix timestamps for use in
WHERE created_at BETWEEN x AND yclauses. - Log analysis: Translate log timestamps to understand the timeline of events during an incident.
- Certificate monitoring: Check when an SSL certificate expires by converting its
notAftertimestamp. - Scheduled tasks: Calculate the timestamp for "next Monday at 9 AM" to use in cron expressions or job schedulers.
- Cache invalidation: Set cache TTL values by computing future timestamps.
- Analytics: Convert event timestamps for charting and reporting.
Try It Now
No signup, no installation, no server calls. Open the Timestamp Converter, paste any Unix timestamp, and see the date in six different formats. Or enter a human-readable date and get the Unix timestamp instantly. Use the relative time calculator for "3 days ago" or "2 weeks from now" calculations.
Looking for more free developer tools? Browse our full tools directory — including Cron Expression Generator, Regex Tester, JWT Decoder, and more.