Current Unix Timestamp (seconds)
0
1970-01-01T00:00:00.000Z
Accepts: Unix seconds (1710000000), Unix ms (1710000000000), ISO 8601 (2024-03-10T00:00:00Z), or any parseable date string
Enter a timestamp above to convert -- or click Copy on the live clock to use the current time
Current time in all timezones
UTC01/01/1970, 00:00:00
America/New York31/12/1969, 19:00:00
America/Chicago31/12/1969, 18:00:00
America/Denver31/12/1969, 17:00:00
America/Los Angeles31/12/1969, 16:00:00
America/Sao Paulo31/12/1969, 21:00:00
Europe/London01/01/1970, 01:00:00
Europe/Paris01/01/1970, 01:00:00
Europe/Berlin01/01/1970, 01:00:00
Europe/Moscow01/01/1970, 03:00:00
Asia/Dubai01/01/1970, 04:00:00
Asia/Karachi01/01/1970, 05:00:00
Asia/Kolkata01/01/1970, 05:30:00
Asia/Dhaka01/01/1970, 06:00:00
Asia/Bangkok01/01/1970, 07:00:00
Asia/Shanghai01/01/1970, 08:00:00
Asia/Tokyo01/01/1970, 09:00:00
Asia/Seoul01/01/1970, 09:00:00
Australia/Sydney01/01/1970, 10:00:00
Pacific/Auckland01/01/1970, 12:00:00
Code reference
Getting the current Unix timestamp in 8 languages
Copy-ready snippets for JavaScript, Python, PHP, Go, Ruby, Java, Rust, and SQL
# JavaScript / TypeScript
Math.floor(Date.now() / 1000) // seconds
Date.now() // milliseconds
new Date(ts * 1000).toISOString() // seconds ts -> ISO 8601
# Python
import time; int(time.time()) # seconds
from datetime import datetime, timezone
int(datetime.now(timezone.utc).timestamp())
# PHP
time() // seconds
# Go
import "time"
time.Now().Unix() // seconds
time.Now().UnixMilli() // milliseconds
# Ruby
Time.now.to_i # seconds
# Java
System.currentTimeMillis() / 1000L // seconds
# Rust
use std::time::{SystemTime, UNIX_EPOCH};
SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs()
# SQL (PostgreSQL)
EXTRACT(EPOCH FROM NOW())::BIGINT -- seconds
-- MySQL
UNIX_TIMESTAMP() -- secondsWhat this tool does
Free Unix timestamp converter -- convert epoch time to human-readable dates, ISO 8601, RFC 2822, and 20 timezones online
How this timestamp converter works, what formats it supports, and why Unix timestamps are used across databases, APIs, and software development
This free Unix timestamp converter accepts any timestamp or date string input and instantly converts it to six output formats simultaneously: Unix seconds, Unix milliseconds, ISO 8601, RFC 2822, human-readable localised time in your selected timezone, and a relative time description such as "3 days ago" or "2 hours from now". The input parser automatically handles the full range of timestamp formats -- pure integer Unix seconds (10 digits, e.g. 1710000000), JavaScript milliseconds (13 digits, e.g. 1710000000000, auto-detected by the value exceeding one trillion), ISO 8601 datetime strings, RFC 2822 strings, and natural date strings parseable by the JavaScript Date constructor. All processing runs entirely client-side in your browser -- no data is ever transmitted to any server, making it safe to use with sensitive log data, internal API responses, and database records.
The tool includes several features beyond basic conversion. The live clock at the top of the tool card updates every second using a setInterval React hook that calls Math.floor(Date.now() / 1000), displaying the current Unix epoch seconds and ISO 8601 string with a one-click copy button for immediate use in API calls, database queries, and development tasks. The timezone selector allows you to choose from 20 globally distributed IANA timezone identifiers -- from UTC and the US regions through Europe, the Middle East, South and Southeast Asia, East Asia, and Oceania -- and the human-readable output row shows your timestamp converted to that zone using the browser's Intl.DateTimeFormat API. The timezone grid at the bottom of the tool card shows the same moment (either your entered timestamp or the current time if no input is provided) displayed across all 20 timezones simultaneously, making cross-timezone scheduling and debugging straightforward without needing to calculate offsets manually.
Unix timestamps are foundational to computing and appear at every layer of the technology stack. In databases, created_at and updated_at columns are frequently stored as integer Unix timestamps for efficient indexing and arithmetic -- comparing timestamps is a simple integer subtraction. In authentication systems, JWT tokens use iat (issued at) and exp (expiry) claims as Unix timestamps to encode when a token was created and when it should be rejected. In distributed systems, timestamps are used for event ordering and conflict resolution. In web APIs, REST and GraphQL responses include timestamps as integers or ISO 8601 strings for date fields. In observability and monitoring, log aggregation systems like Elasticsearch and Splunk index events by Unix timestamps for efficient range queries. In email infrastructure, SMTP message dates use RFC 2822 format. This converter handles all of these contexts, making it useful for backend developers debugging API responses, frontend engineers parsing event data, DevOps engineers reading log timestamps, and database administrators working with time-series data.
Features and formats
Auto s/ms Detection
Automatically distinguishes Unix seconds (10 digits) from JavaScript milliseconds (13 digits) without any manual selection required.
Unix Seconds Output
Outputs the standard Unix epoch seconds integer used by databases, JWT tokens, cron jobs, and server-side programming languages.
Unix Milliseconds
Outputs the JavaScript Date.now() milliseconds format used by browser APIs, Node.js, analytics pipelines, and localStorage.
ISO 8601
International standard date format (2024-03-10T14:30:00.000Z) used in JSON APIs, HTML datetime attributes, and log systems.
RFC 2822
Email date format (Sat, 09 Mar 2024 20:00:00 GMT) used in SMTP headers, HTTP response headers, and RSS and Atom feeds.
Human Readable
Localised natural language output with your selected timezone applied: 'Saturday, March 9, 2024 at 8:00:00 PM UTC'.
Relative Time
Context-aware relative description such as '3 days ago' or '2 hours from now' -- useful for debugging expiry and scheduling logic.
20 IANA Timezones
Convert to any of 20 IANA timezone identifiers from UTC to Pacific/Auckland using the browser's Intl.DateTimeFormat API.
Live Clock
Continuously updating current Unix timestamp in seconds and ISO 8601, refreshing every second via a React useEffect setInterval.
Timezone Grid
Shows the entered or current timestamp simultaneously across all 20 supported timezones for at-a-glance zone comparison.
One-Click Copy
Every output row and the live clock have a copy button for instant clipboard access without manual text selection.
Client-Side Only
Zero server requests -- all conversion logic runs in your browser using the JavaScript Date API and Intl.DateTimeFormat.
Examples
Unix timestamp conversion examples -- seconds, milliseconds, ISO 8601 input, timezone output, and future scheduling
Five real-world timestamp scenarios showing input formats, conversion outputs, and developer use cases
ExcellentUnix seconds -- standard API, JWT, and database format
Input: 1710000000
Unix (seconds): 1710000000
Unix (milliseconds): 1710000000000
ISO 8601: 2024-03-09T20:00:00.000Z
RFC 2822: Sat, 09 Mar 2024 20:00:00 GMT
Human readable: Saturday, March 9, 2024 at 8:00:00 PM UTC
Relative: about 1 year ago
A standard 10-digit Unix seconds timestamp as used in database created_at columns, JWT iat and exp fields, and REST API responses. This tool converts it to all six output formats simultaneously. The ISO 8601 output is the correct format to use in JSON APIs, HTML datetime attributes, and log aggregation systems.
ExcellentJavaScript milliseconds -- Date.now() auto-detected
Input: 1710000000000
Auto-detected as: milliseconds (value > 1,000,000,000,000)
Unix (seconds): 1710000000
Unix (milliseconds): 1710000000000
ISO 8601: 2024-03-09T20:00:00.000Z
Human readable: Saturday, March 9, 2024 at 8:00:00 PM UTC
A 13-digit milliseconds timestamp as returned by JavaScript's Date.now(). The tool automatically detects that values above one trillion are in milliseconds and converts accordingly. This is the format stored in browser localStorage, analytics event payloads, and many Node.js application logs.
GoodISO 8601 string input -- reverse conversion to Unix
Input: 2025-06-15T09:30:00Z
Unix (seconds): 1749983400
Unix (milliseconds): 1749983400000
ISO 8601: 2025-06-15T09:30:00.000Z
RFC 2822: Sun, 15 Jun 2025 09:30:00 GMT
Human readable: Sunday, June 15, 2025 at 9:30:00 AM UTC
Relative: about 3 months from now
An ISO 8601 datetime string used as input to produce the Unix timestamp equivalent. This reverse conversion is useful when you have a human-readable date and need the integer timestamp for database insertion, API parameter construction, or setting cookie expiry values in code.
GoodTimezone conversion -- same moment across 4 zones
Input: 1710000000 (2024-03-09 20:00:00 UTC)
UTC: 09/03/2024, 20:00:00
America/New_York: 09/03/2024, 15:00:00 (UTC-5, EST)
Europe/London: 09/03/2024, 20:00:00 (UTC+0, GMT)
Asia/Kolkata: 10/03/2024, 01:30:00 (UTC+5:30, IST)
Asia/Tokyo: 10/03/2024, 05:00:00 (UTC+9, JST)
The same Unix timestamp displayed in four different timezones shows how offset adjustments work. New York is 5 hours behind UTC in winter, Kolkata is 5.5 hours ahead (the half-hour offset is a real-world quirk), and Tokyo is 9 hours ahead. The timezone grid at the bottom of the tool shows all 20 supported zones simultaneously.
GoodFuture timestamp -- JWT expiry and cookie scheduling
Input: 2030-01-01T00:00:00Z
Unix (seconds): 1893456000
Unix (milliseconds): 1893456000000
ISO 8601: 2030-01-01T00:00:00.000Z
Human readable: Tuesday, January 1, 2030 at 12:00:00 AM UTC
Relative: about 4 years from now
JWT exp claim: { "exp": 1893456000 }
Cookie Expires: Wed, 01 Jan 2030 00:00:00 GMT
Future timestamps are used for JWT token expiry (exp claim), cookie expiration headers, scheduled task targets, and countdown timers. The relative output shows how far in the future the timestamp is, which is useful for sanity-checking that expiry windows are set correctly in authentication and session management code.
FAQ
Frequently asked questions about Unix timestamps, epoch conversion, ISO 8601, timezones, and the Year 2038 problem
Common questions about how Unix timestamps work, how to convert them in different languages, and what formats APIs and databases use
What is a Unix timestamp and where is it used?
A Unix timestamp (also called epoch time or POSIX time) is the number of seconds that have elapsed since the Unix epoch -- midnight on January 1, 1970 UTC. It is a timezone-independent integer representation of a specific moment in time used pervasively in computing: as primary keys and created_at fields in relational databases, in API response payloads and JWT tokens, in server log files and event tracking systems, in file system modification times, in distributed systems for event ordering, and in virtually every programming language's standard library date/time functions. The key advantage is simplicity -- a single integer unambiguously identifies a moment in time without timezone ambiguity.
What is the difference between Unix timestamps in seconds vs milliseconds?
Traditional Unix timestamps count seconds since the epoch. A seconds-precision timestamp for early 2024 looks like 1710000000 -- ten digits. However, JavaScript's Date.now() and many modern web APIs return milliseconds since the epoch, which is the seconds value multiplied by 1000. A milliseconds timestamp for the same moment looks like 1710000000000 -- thirteen digits. The practical rule: if the value is greater than 1,000,000,000,000 (one trillion), it is in milliseconds. If it is ten digits, it is in seconds. This tool automatically detects which format you have entered and converts accordingly, displaying both seconds and milliseconds versions in the output.
How do I convert a Unix timestamp to a human-readable date in JavaScript?
In JavaScript, pass the timestamp to the Date constructor after multiplying by 1000 to convert seconds to milliseconds: new Date(timestamp * 1000). If you already have a milliseconds timestamp, use new Date(timestamp) directly. To format the result, use toISOString() for ISO 8601 format (e.g. 2024-03-10T12:00:00.000Z), toUTCString() for RFC 2822 format, or toLocaleString() with a timeZone option for localised human-readable output. In TypeScript, the same approach works -- the Date constructor accepts a number argument. This tool shows all of these formats simultaneously for any timestamp you enter.
How do I get the current Unix timestamp in different programming languages?
The method varies by language. In JavaScript and TypeScript: Math.floor(Date.now() / 1000) gives seconds, or Date.now() for milliseconds. In Python: import time; int(time.time()) gives seconds. In PHP: time() returns seconds. In Go: time.Now().Unix() for seconds or time.Now().UnixMilli() for milliseconds. In Ruby: Time.now.to_i for seconds. In Java: System.currentTimeMillis() / 1000L for seconds. In Rust: SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs(). In SQL PostgreSQL: EXTRACT(EPOCH FROM NOW())::BIGINT. In Unix shell: date +%s. The live clock on this tool shows the current value updating every second.
What is ISO 8601 format and how does it differ from a Unix timestamp?
ISO 8601 is the international standard for representing dates and times as human-readable strings. The standard format looks like 2024-03-15T14:30:00.000Z, where T separates the date and time portions and the Z suffix indicates UTC. Timezone offsets can be expressed as +05:30 or -07:00 instead of Z. Unlike Unix timestamps (which are pure integers), ISO 8601 strings are immediately readable by humans without conversion. ISO 8601 is used by JavaScript's Date.toISOString(), in JSON API responses, in HTML datetime attributes, in database TIMESTAMP columns, and in most log aggregation systems that need human-readable timestamps alongside machine-parseable ones.
What is the Year 2038 problem and does it affect modern systems?
The Year 2038 problem (also called Y2K38 or the Unix Millennium Bug) occurs because many legacy systems store Unix timestamps as 32-bit signed integers. A 32-bit signed integer can hold a maximum value of 2,147,483,647, which corresponds to January 19, 2038 at 03:14:07 UTC. After this moment, a 32-bit signed counter overflows and wraps to a large negative number, potentially causing system failures and corrupted data. Modern 64-bit operating systems and languages store timestamps as 64-bit integers, which can represent dates approximately 292 billion years into the future, effectively eliminating the problem. However, legacy embedded systems, 32-bit databases, and older firmware may still be affected and require migration before 2038.
How do I convert a Unix timestamp to a specific timezone?
Unix timestamps are inherently timezone-neutral -- they represent an absolute moment in time with no timezone information embedded. To display a Unix timestamp in a specific timezone, you must apply a timezone offset during formatting. In JavaScript: new Date(timestamp * 1000).toLocaleString('en-US', { timeZone: 'America/New_York' }). In Python: datetime.fromtimestamp(ts, tz=ZoneInfo('America/New_York')). In this tool, select any of the 20 supported timezones from the dropdown and the human-readable output row will display the timestamp in your selected zone. The timezone grid at the bottom of the tool card shows the same moment across all 20 zones simultaneously.
What is RFC 2822 date format and when is it used?
RFC 2822 is the standard that defines the format of Internet email messages, and includes a specific date-time format used in email headers. The format looks like Mon, 15 Mar 2024 14:30:00 +0000. The components are: abbreviated day of week, day number, abbreviated month name, four-digit year, time in HH:MM:SS format, and timezone offset as +HHMM or -HHMM. In JavaScript, Date.toUTCString() produces a close approximation. RFC 2822 dates appear in email headers (the Date: field), in HTTP response headers, in RSS and Atom feed entries, and in some legacy API responses. It is less commonly used in modern systems than ISO 8601 but remains important for email-related development and integration work.
How do I convert a date string to a Unix timestamp?
To convert a human-readable date string to a Unix timestamp, divide the milliseconds representation by 1000. In JavaScript: Math.floor(new Date('2024-03-15T14:30:00Z').getTime() / 1000). The Date constructor accepts ISO 8601 strings, RFC 2822 strings, and many common formats. In Python: int(datetime.fromisoformat('2024-03-15T14:30:00+00:00').timestamp()). In PHP: strtotime('2024-03-15 14:30:00 UTC'). In this tool, you can paste any date string directly into the input field -- ISO 8601, RFC 2822, or natural language formats like '2024-03-15 14:30:00' -- and it will automatically convert to Unix seconds, Unix milliseconds, and all other output formats simultaneously.
How does the live Unix timestamp clock on this tool work?
The live clock uses JavaScript's setInterval function to update the displayed timestamp every second. The implementation calls Math.floor(Date.now() / 1000) on each tick to get the current Unix seconds value, and also derives the ISO 8601 representation from the same Date object. The clock starts immediately when the page loads using a React useEffect hook and cleans up the interval when the component unmounts to prevent memory leaks. The current timestamp displayed is always in UTC seconds since the Unix epoch -- it does not adjust for your local timezone because Unix timestamps are timezone-agnostic by definition. Clicking the Copy button next to the live clock copies the current seconds value to your clipboard instantly for use in queries, API calls, or development tasks.
Related Tools
Need a disposable email address?Stop giving your real email to sites you don't trust -- get a free instant throwaway with no signup and no trace.
Get Free Temp Mail ->