Unix Timestamp Converter
Convert Unix timestamps to human-readable dates and vice versa. Auto-detects seconds, milliseconds, and microseconds — all in your browser.
Every developer encounters Unix timestamps, and nearly every developer has been burned by the seconds-vs-milliseconds confusion at least once. A timestamp is just a number — but whether that number means seconds (10 digits), milliseconds (13 digits), or microseconds (16 digits) determines whether your converted date is in 2024 or a far-future year around 55,000 AD.
This tool handles all three resolutions automatically. Paste any numeric timestamp and it detects the digit count, converts to UTC and local time, and outputs ISO 8601, epoch seconds, and epoch milliseconds. You can also pick a local date and time to get the corresponding timestamps — useful for creating test data, scheduling jobs, or setting JWT expiration claims.
Every conversion runs entirely in your browser using the native JavaScript Date API. Your input is never transmitted — which means it is fast and private, but also means you should never paste real production data or API keys into any browser-based tool.
Current Unix timestamp
Updates every second in your browser's time zone
Epoch Seconds
1,781,322,777
Milliseconds
1,781,322,777,349
ISO 8601
2026-06-13T03:52:57.349Z
UTC
2026-06-13 03:52:57.349 UTC
Try it now
Paste a timestamp or pick a date — get results instantly
10-digit values = seconds, 13-digit = milliseconds, 16-digit = microseconds. Auto-detected.
Ready after you click an action
Quick example — 10-digit vs 13-digit, same moment
1700000000
→ 2023-11-14 22:13:20 UTC
1700000000000
→ Same moment, ×1000 precision
Common timestamp mistakes (and how to fix them)
Click any example to load its timestamp into the tool.
Understanding Unix timestamps
Seconds vs. milliseconds: the most important distinction
A Unix timestamp is fundamentally seconds since the epoch. But many platforms multiply by 1,000 for millisecond precision. Recognizing which you have is the first step:
| Digits | Unit | Typical source | Example |
|---|---|---|---|
| 10 | Seconds | Python, Go, PHP, shell, C, Rust | 1700000000 |
| 13 | Milliseconds | JavaScript, Java, Swift, Kotlin | 1700000000000 |
| 16 | Microseconds | Kafka, Elasticsearch, Prometheus | 1700000000000123 |
UTC vs. local time: always compare in UTC first
A Unix timestamp is always UTC-based. Two events with the same timestamp happened at the exact same instant, regardless of where in the world they were recorded. Confusion arises when you display the timestamp in a local time zone and compare it with another system showing UTC.
Correct approach
Convert to UTC first for comparison and storage. Apply the user's time zone offset only at the display layer. This keeps your data consistent regardless of where your servers, databases, and users are located.
Common mistake
Storing local wall-clock times (e.g. "3:00 PM Eastern") in place of UTC timestamps. During DST transitions, "2:30 AM" happens twice or not at all — and without an offset, you cannot tell which one was intended.
ISO 8601: the universal date-time format
ISO 8601 (2024-01-15T14:30:00.000Z) is the standard text representation of a date and time. The T separates date from time, and the trailing Z means UTC (Zulu time). It is unambiguous, sortable alphabetically, and supported by every modern programming language and database. This tool outputs ISO 8601 for every conversion so you always have a portable, unambiguous date string.
The Year 2038 problem
A signed 32-bit integer can hold values up to 2,147,483,647. When a 32-bit system stores a Unix timestamp, this maximum value corresponds to January 19, 2038 at 03:14:07 UTC. One second later, the integer overflows to −2,147,483,648, which represents December 13, 1901.
Max 32-bit value
2147483647
Jan 19, 2038 03:14:07 UTC
Overflow result
−2147483648
Dec 13, 1901 20:45:52 UTC
64-bit safe until
~292 billion
Far beyond the Sun’s lifespan
Most modern 64-bit systems are immune, but embedded devices (routers, IoT sensors, automotive ECUs), legacy database schemas, old file systems (ext3 with 32-bit inode timestamps), and industrial controllers may still be vulnerable. If you maintain systems with long lifecycles, verify 64-bit time_t support now.
Real-world use cases
Debugging API response timestamps
REST APIs, GraphQL responses, and webhooks often return timestamps in seconds or milliseconds. Convert them here to confirm the event time matches your expectations before investigating further.
Checking JWT token expiration
JWT exp, iat, and nbf claims are numeric timestamps in seconds. Paste the exp value here to see when a token expires in human-readable UTC and local time. For full token inspection, use the JWT Decoder tool.
Comparing server and database times
During incident response, you may have timestamps from application logs (ISO 8601), database rows (epoch seconds), and browser DevTools (epoch milliseconds). Convert everything to UTC to establish the true event order.
Creating test data and seed scripts
Need a specific date as a timestamp for test fixtures, database seeds, or API mock responses? Enter the date here and get the exact epoch second and millisecond values to paste into your code.
Scheduling and cron debugging
Cron expressions, job schedulers, and task queues often use epoch timestamps. Convert a scheduled time to timestamp format to confirm the job will fire when you expect — accounting for UTC vs local time.
Reviewing analytics and event data
Analytics platforms, CDN logs, and monitoring tools frequently emit millisecond or microsecond timestamps. Convert representative values here to verify that events are being recorded in the correct time range.
When not to rely on a browser timestamp tool
- Production scheduling: For cron jobs, task queues, and scheduled events, use your backend language's time library — not a browser tool. Server time zone configuration, NTP sync, and DST rules must be handled server-side.
- Cryptographic operations: Timestamps in token expiration, certificate validity, and signature windows require a trusted, monotonic clock. Browser time can be changed by the user.
- Audit logs and compliance: Regulatory requirements often mandate tamper-proof timestamps from a trusted time source. Browser-generated timestamps are not suitable for audit trails.
- High-frequency time series: For sub-millisecond precision or millions of data points, use a time-series database (InfluxDB, TimescaleDB) with native timestamp support rather than converting values one at a time in a browser.
Security and privacy
All timestamp conversions run entirely in your browser. Your input values are never uploaded to any server by this tool. However, never paste sensitive data into any online tool — this includes production API payloads containing timestamps, JWT tokens with real user data, or any timestamp values that could reveal business-sensitive timing information. Browser extensions, clipboard managers, and device-level software can read textarea content.
Frequently asked questions
What is a Unix timestamp?
A Unix timestamp counts seconds (or milliseconds) since January 1, 1970 00:00:00 UTC — the Unix epoch. It is the most common way computers store and exchange time because it is a simple number with no time zone ambiguity. Ten-digit values are typically seconds; thirteen-digit values are typically milliseconds.
Why are there 10-digit and 13-digit timestamps?
Ten-digit values represent seconds since the epoch. Thirteen-digit values represent milliseconds since the epoch — the same moment, but 1,000 times more precise. If you accidentally treat a 13-digit millisecond value as seconds, you get a date around a far-future year around 55,000 AD instead of the present. This tool auto-detects the digit count and converts correctly.
What is the Year 2038 problem?
On 32-bit systems, a signed 32-bit integer can only count up to 2,147,483,647 seconds from the epoch, which overflows on January 19, 2038 at 03:14:07 UTC — wrapping around to December 1901. Most modern 64-bit systems are immune, but embedded devices, legacy databases, and old file systems can still be affected. If you work with 32-bit ARM devices, industrial controllers, or older POSIX systems, check your timestamp handling before 2038.
Why does my converted time look several hours off?
Timestamps are time-zone neutral — they always count from UTC. The displayed time changes based on your local time zone. When comparing timestamps from servers, databases, and browsers, always convert to UTC first, then adjust for display. A common mistake is comparing a UTC-converted time from one tool with a local-time display from another.
Is my data uploaded to a server?
No. All conversions run entirely in your browser using the JavaScript Date API. Your input values and converted dates are never transmitted by this tool. The page may load analytics or advertising scripts that send page-view data, but your timestamp content stays on your machine.
Should I store UTC or local time in my database?
Store UTC timestamps. Convert to local time only for display to users. This avoids bugs from daylight saving time shifts, server time zone changes, and cross-region data comparison. Storing local time means you lose the ability to compare events across time zones without guessing the original offset.
Can I convert timestamps with microseconds or nanoseconds?
This tool supports up to 16-digit microsecond timestamps by truncating to milliseconds. Many systems (Kafka, Elasticsearch, some monitoring tools) produce microsecond or nanosecond timestamps. For nanosecond precision or high-frequency time series, use a dedicated time library in your programming language — JavaScript's Date only has millisecond resolution.
Related tools you might need
Decode JWT tokens and inspect exp/iat/nbf claims with timestamp conversion.
Encode text to Base64 or decode Base64 strings back to readable text.
Format, validate, and minify JSON in your browser.
Test JavaScript regular expressions against sample text with clear match output.
Tool guide
About Timestamp Converter
Unix timestamps are used in logs, APIs, databases, JWT claims, analytics events, and scheduled jobs. This converter helps you quickly turn raw epoch values into readable dates and convert dates back into timestamp values.
The most common confusion is seconds versus milliseconds. Ten-digit values are usually seconds, while thirteen-digit values are usually milliseconds. Mixing them can produce dates that are far in the past or future.
When debugging distributed systems, compare UTC first, then convert to local time for user-facing explanations. Time zone display issues are often mistaken for bad timestamps.
Privacy note
Most FreeToolsBox tools run directly in your browser for processing. Some pages may still load analytics, ads, or third-party services. Avoid entering passwords, private keys, production tokens, personal IDs, or other sensitive data.
Validation-grade guide
How to use Timestamp Converter well
Best for
Convert Unix timestamps to readable dates and dates back to epoch time.
Helps debug logs, tokens, schedules, and API data where time is represented as seconds or milliseconds.
Example workflow
- Input: 1716000000
- Action: Convert the Unix timestamp and compare local and UTC output.
- Expected result: The same instant is shown in readable formats so logs can be compared across systems.
Quality checks
- Distinguishes seconds, milliseconds, local time, and UTC context.
- Works well with JWT exp/iat checks and log analysis.
- Tracks conversion actions separately from passive page views.
Watch out for
- 10-digit values are usually seconds; 13-digit values are usually milliseconds.
- Date-only inputs can shift if interpreted as UTC instead of local time.
- Timezone abbreviations can be ambiguous.
Do not use it for
- Legal deadline calculations without checking the relevant jurisdiction and timezone.
- Scheduling recurring jobs where daylight saving rules matter.
What to measure in the 90-day validation
- tool_used:timestamp-to-date
- tool_used:date-to-timestamp
- tool_error rate
Timestamp conversion is computed in the browser using the device timezone where applicable.
Learn the concept
Seconds vs milliseconds
A guide to recognizing Unix timestamp units, converting UTC and local time correctly, and avoiding common API, log, and JWT time mistakes.
Read the guide →Common use cases
- Convert API response timestamps into readable dates.
- Check whether log entries line up with local time or UTC.
- Convert a planned date into a timestamp for seed data or test cases.
- Debug JWT exp, iat, and nbf claims alongside token payloads.
- Compare database, browser, and server times during incident investigation.
Examples
- Convert a 10-digit Unix timestamp from an API response into a readable UTC date.
- Convert a 13-digit JavaScript millisecond timestamp before comparing it with backend logs.
- Create a future timestamp for a test token expiration or scheduled job.
Practical tips
- Ten-digit timestamps usually mean seconds; thirteen-digit values usually mean milliseconds.
- Use UTC when comparing timestamps across servers, databases, and clients.
- When a converted time looks off by several hours, check the displayed time zone first.
- JWT exp, iat, and nbf claims are normally expressed as seconds, not milliseconds.
Related tools
Frequently asked questions
What is a Unix timestamp?
A Unix timestamp is a number that represents time elapsed since 1970-01-01 00:00:00 UTC, usually in seconds or milliseconds.
What is the difference between seconds and milliseconds timestamps?
Second-based timestamps are commonly ten digits, while millisecond-based timestamps are commonly thirteen digits. Mixing them can produce dates that are far in the past or future.
Why does my converted time look several hours wrong?
The timestamp itself is usually time zone neutral. The displayed date can change depending on whether you view it in UTC or your local time zone.
Are JWT expiration times seconds or milliseconds?
JWT NumericDate values such as exp, iat, and nbf are normally seconds since the Unix epoch.
Should I store local time or UTC?
For systems and databases, UTC timestamps are usually safer. Convert to local time only when displaying dates to users.
Is Timestamp Converter free to use?
Yes. Timestamp Converter is free to use in your browser with no signup required.