Unix Timestamp Converter
ConvertersConvert between Unix timestamps (epoch) and human-readable dates. Free, private — all processing in your browser.
00See the current Unix timestamp ticking live in every format you might need, convert a timestamp into a readable date (with the relative "3 days ago", the weekday, and the week number), or go the other way and turn a date into its timestamp. It auto-detects whether you pasted seconds (10 digits) or milliseconds (13 digits), which is the single most common source of "my date is in 1970 or the year 55000" bugs.
Everything's computed in your browser — no server clock, no upload — and dates are shown both in your local time and in UTC/ISO so there's no guessing which one you're looking at.
Using the Unix Timestamp Converter
- 1
Pick direction: timestamp → date or date → timestamp
Use the first mode if you have a number like `1714521600`. Use the second if you have a date.
- 2
Enter the value
Paste or type. Auto-detection handles seconds vs milliseconds vs date formats. Correct manually if needed.
- 3
Choose timezone
UTC by default. Change to your local time or any IANA timezone for display.
- 4
View all formats
Every common format is shown simultaneously — ISO, RFC, SQL, Unix date. Copy whichever you need.
- 5
See relative time
Human-readable "2 hours ago" makes it easy to understand when the timestamp occurred.
- 6
Copy and use
Copy the desired format for your code, database query, or API call.
Unix Timestamp Converter — examples
Timestamp to date (UTC)
Classic conversion.
1714521600
UTC: 2024-05-01 00:00:00 ISO 8601: 2024-05-01T00:00:00Z Relative: May 1, 2024 (1 year ago)
Milliseconds to date
JavaScript Date.now() value.
1714521600000
Detected: milliseconds UTC: 2024-05-01 00:00:00 Local (EDT): 2024-04-30 20:00:00
Date to timestamp
ISO 8601 to Unix.
2026-05-05T14:23:01Z
Unix timestamp (seconds): 1762349381 Unix timestamp (milliseconds): 1762349381000
Current timestamp
Right now.
Click "Now"
Unix timestamp: 1714521900 Date: May 1, 2024, 12:05:00 AM UTC Updates every second
Timezone display
Same timestamp, different timezones.
1714521600 in multiple timezones
UTC: 2024-05-01 00:00:00 America/New_York: 2024-04-30 20:00:00 (EDT) Europe/London: 2024-05-01 01:00:00 (BST) Asia/Tokyo: 2024-05-01 09:00:00 (JST)
Timestamp arithmetic
Calculate duration between two timestamps.
Start: 1714521600 (May 1 00:00 UTC) End: 1714525200 (May 1 01:00 UTC)
Duration: 3600 seconds = 1 hour = 60 minutes
Future timestamp for JWT
Token expires in 1 hour.
Now + 3600
Current: 1714521600 + 3600 seconds = 1714525200 (1 hour from now) Use as JWT exp claim
Unix Timestamp Converter — key features
Seconds and milliseconds
Auto-detect whether input is seconds (10 digits) or milliseconds (13 digits). Manually override if needed.
Current timestamp
One-click button shows the current Unix timestamp updating in real-time. Copy for immediate use.
All date formats
ISO 8601, RFC 3339, RFC 2822, HTTP date, SQL timestamp, custom — see the same moment in every format.
Timezone conversion
Display the timestamp in UTC, your local timezone, or any named IANA timezone (America/New_York, Asia/Tokyo, etc.).
Date to timestamp
Type or pick a date, get the Unix timestamp. Supports past dates (back to 1970) and future dates (up to Year 9999).
Relative time
Shows "2 hours ago" or "in 3 days" for any timestamp. Great for quick orientation.
Bulk conversion
Paste a list of timestamps (one per line), get all converted at once. Useful for log file analysis.
100% client-side
All conversion runs in your browser. No data uploaded, safe for server logs and internal data.
Common use cases for the Unix Timestamp Converter
API development
- →Debug API responses with timestamps: When an API returns `created_at: 1714521600`, convert instantly to see what date that is.
- →Construct JWT exp claims: JWT `exp` is a Unix timestamp. Calculate: now + 1 hour for a 1-hour expiring token.
- →Parse AWS S3 signed URLs: S3 signed URLs contain an expiration timestamp. Convert to check when the URL expires.
- →Rate limit X-RateLimit-Reset: HTTP headers often include a reset timestamp. Convert to know when your rate limit resets.
Database work
- →Query by timestamp: Write SQL queries against INTEGER timestamp columns: `WHERE created_at > 1714521600` for rows created after a specific date.
- →Convert stored timestamps: Many legacy databases store timestamps as integers. Convert to inspect records without running SQL conversion.
- →Time-range analysis: Convert dates to timestamps for range queries. `BETWEEN 1714521600 AND 1714608000` for specific 24-hour windows.
Log analysis
- →Understand log timestamps: Nginx, Apache, AWS CloudTrail logs use epoch time. Convert to local time while debugging.
- →Calculate event duration: Subtract two timestamps to get elapsed time. `end - start = duration in seconds`.
- →Audit log investigation: When investigating incidents, convert log timestamps to your timezone to match local events (meetings, deployments, etc.).
Development and testing
- →Create expiration timestamps: Need a token that expires in 1 hour? Now + 3600 seconds = 1 hour from now timestamp.
- →Mock data generation: Generate timestamps for test data: past events, future scheduled jobs, session creation times.
- →Migration scripts: When importing legacy data with date strings, convert to timestamps for consistency.
How it works
A Unix timestamp is the number of seconds since 1970-01-01 00:00:00 UTC — a single integer that means the same instant everywhere on Earth, which is exactly why systems store time this way and convert to local zones only for display.
Seconds vs milliseconds — the gotcha this tool guards against. Unix/Linux and most databases use *seconds* (a 10-digit number today). JavaScript's Date.now() uses *milliseconds* (13 digits). Feed seconds to something expecting ms (or vice-versa) and you're off by a factor of 1000 — a 2024 date lands in 1970 or far in the future. The converter checks the magnitude and interprets accordingly.
Timezones. The timestamp itself has no timezone — it's UTC by definition. What varies is *display*. This tool shows the UTC/ISO form (unambiguous, good for storage and APIs) and your browser's local form (what a human in your zone sees). When two systems "disagree" about a time, it's almost always a display-timezone difference, not a different instant.
The year 2038 problem. Systems that store the timestamp in a signed 32-bit integer overflow on 2038-01-19. Modern systems use 64-bit and are fine, but it's why you'll see 64-bit time everywhere now.
Pitfalls and fixes
⚠Off by a factor of 1000 (date in 1970 or the far future)
You mixed seconds and milliseconds. Unix uses seconds (10 digits); JavaScript uses milliseconds (13 digits). Multiply or divide by 1000 to match what the consuming system expects. This tool auto-detects on input.
⚠Times seem wrong by a few hours
That's a timezone display difference, not a wrong instant. A timestamp is UTC; your local view shifts by your offset. Compare the UTC/ISO values to confirm two systems actually agree.
⚠Storing a formatted local date string
Strings like '5:13 PM' lose timezone and can't be sorted or compared reliably. Store the Unix timestamp or ISO-8601 UTC and format only when displaying.
⚠Assuming 32-bit time is safe past 2038
Signed 32-bit timestamps overflow on 2038-01-19. If you control storage, use 64-bit integers (or a proper timestamp type) so far-future dates don't wrap around.
⚠Leap seconds and sub-second precision
Unix time ignores leap seconds and, in seconds form, drops fractions. If you need millisecond precision, store milliseconds; don't expect second-level timestamps to round-trip finer detail.
Unix Timestamp Converter — comparisons and alternatives
Unix timestamp vs ISO 8601. The timestamp (1700000000) is compact, easy to compare and do math on, and timezone-free — great for storage and internal use. ISO 8601 (2023-11-14T22:13:20Z) is human-readable and self-documenting — better for logs, APIs, and anywhere a person will read it. Store one, display the other.
Seconds vs milliseconds. Pick one and be consistent within a system. Unix tools, Postgres, and most backends speak seconds; JavaScript and many JS APIs speak milliseconds. The bugs happen at the boundary — always know which unit a given field uses.
Timestamp vs a formatted local string. Never store a formatted local date string ("11/14/2023 5:13 PM") — it's ambiguous about timezone and locale and can't be compared reliably. Store the timestamp (or ISO-8601 UTC) and format for display at the edge.
Unix Timestamp Converter — FAQ
▶Is a Unix timestamp in seconds or milliseconds?
Classic Unix time is seconds since 1970 (10 digits today). JavaScript uses milliseconds (13 digits). This tool auto-detects which you pasted, but in your own code always know which unit a field uses — mixing them is off by 1000x.
▶What timezone is a Unix timestamp in?
None — it's UTC by definition, the same instant everywhere. Timezones only matter for display. The tool shows both UTC/ISO and your local time so you can see the difference.
▶Can it convert both directions?
Yes. Paste a timestamp to get the date (plus relative time and weekday), or pick a date and time to get the timestamp in seconds and milliseconds. There's also a live current-time view.
▶Is the current time from a server?
No — it reads your device clock in the browser and updates live. Nothing is fetched or uploaded, so it's accurate to however your computer's clock is set.
▶What is the year 2038 problem?
Timestamps stored in a signed 32-bit integer overflow on 2038-01-19 and wrap to negative (1901). Modern 64-bit systems aren't affected, which is why 64-bit time is now standard.
▶Why does my date show as 1970?
You almost certainly passed milliseconds where seconds were expected, or a value of 0/near-zero. A tiny timestamp maps to just after the 1970 epoch — check the unit and magnitude.
Further reading
- Wikipedia — Unix Time — Comprehensive reference on Unix time and the Year 2038 problem.
- ISO 8601 Date Format — International standard for date and time formats.
- RFC 3339 — IETF spec for internet date/time format.
- MDN — JavaScript Date — JavaScript Date object reference.
- IANA Time Zone Database — Standard timezone database used by operating systems.
Related tools
All ConvertersAge Calculator
Calculate exact age from a birth date in years, months, days, and smaller units with leap-year-accurate arithmetic.
Cron Expression Generator
Build and understand cron expressions — visual editor, plain English explanation
Crontab Guru
Translate cron expressions into plain English, calculate next run times, and explore common scheduling patterns.
Date Difference Calculator
Calculate exact difference between two dates in years, months, weeks, days, hours with optional weekend or holiday exclusion.
Date Formatter
Format dates in any pattern — ISO 8601, US, European, custom strftime tokens — with full timezone and locale support.
Epoch Converter
Convert between Unix epoch timestamps (seconds and milliseconds) and human-readable dates in any timezone with multiple format options.
Learn more
Explore more tools
200+ free tools that run in your browser.
Browse all tools →