Epoch UNIX Timestamp Converter

Convert UNIX timestamps (epoch time) into human-readable date formats with our easy-to-use converter. Discover practical uses, troubleshooting tips, and examples to effectively manage time data across systems

The UNIX timestamp '1704067200' is converted into 2024-01-01

What is a Unix Timestamp / Epoch time?

A Unix timestamp, also known as an "epoch time", represents the number of seconds that have elapsed since January 1, 1970, at 00:00:00 UTC, excluding leap seconds.

This starting point is referred to as the Unix "epoch". The Unix timestamp provides a simple numeric representation of a date and time that is universally recognized across different platforms, making it a standard method for time measurement in computing.

How to Use the Unix Timestamp Converter

To use the Epoch Unix timestamp converter, simply input the Unix timestamp number into the converter and press Enter.

The tool will use the UNIX2DATE function to automatically display the corresponding date and time in a human-readable format, "YYYY-MM-DD". This allows you to easily understand or verify the date and time that a particular timestamp refers to.

Alternatively, input a human-readable date format, such as "YYYY-MM-DD" (or "DD/MM/YYY"). The tool will use the inverse function, UNIXTIME, to return the Epoch timestamp.

Common Uses of Unix Timestamps

Unix timestamps are widely used in programming and database management for various practical purposes. Here are some specific use cases:

  • Recording Events: timestamps are used to record the time when events occur, such as user logins, transactions, or system errors.

  • Data Synchronization: ensuring that data remains consistent across different systems or networks often relies on Unix timestamps to track when data was last updated.

  • File Management: operating systems use Unix timestamps to record creation, modification, and access times of files.

  • Session Management: web applications use timestamps to manage user sessions, typically determining session expiry.

  • Time Series Analysis: in analytics, timestamps serve to organize and analyze data points based on the sequence and duration of events.

Understanding these uses can help developers and administrators utilize Unix timestamps effectively in their respective applications and systems.

Advantages and Uses of Timestamp Formats

Unix timestamps are often represented as either 32-bit or 64-bit integers, depending on the system, making them a compact format ideal for applications that need to store timestamps in a small amount of memory.

This is particularly useful in programming languages such as PHP, Python, and JavaScript. Conversely, ISO time strings, being more human-readable, are advantageous for exchanging date and time information between systems and regions due to their standardized format.

Troubleshooting Conversion Errors

If you encounter an error during conversion, ensure that the Unix timestamp is correctly formatted as a numerical value and falls within a valid range. Errors can occur if the timestamp is too large or small, representing a date outside the valid Unix time range that starts from 1970-01-01.

By understanding and utilizing these different timestamp formats and conversion tools, developers and administrators can better manage and synchronize time-related data across various systems and applications.

Understanding Different Timestamp Formats

In addition to Unix timestamps, there are other commonly used timestamp formats, such as epoch time and ISO time strings. Epoch time, also referred to as Unix time or POSIX time, is essentially the same as a Unix timestamp, representing the number of seconds since the Unix epoch.

However, an ISO time string follows the ISO 8601 standard, represented in a human-readable format like "YYYY-MM-DDTHH:MM:SS" and can include time zone information. This standardized format is widely used for exchanging date and time information between different systems and regions due to its international recognition and ease of parsing.

How to Convert Unix Timestamp in each programming languages

Language

Syntax

PHP

date(output format, epoch); Output format example: 'r' = RFC 2822 date

Python

import time; time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime(epoch)) Replace time.localtime with time.gmtime for GMT time. Or using datetime: import datetime; datetime.datetime.utcfromtimestamp(epoch).replace(tzinfo=datetime.timezone.utc)

Ruby

Time.at(epoch)

Java

String date = new java.text.SimpleDateFormat("MM/dd/yyyy HH:mm:ss").format(new java.util.Date (epoch*1000)); Epoch in seconds, remove '*1000' for milliseconds.

Lua

datestring = os.date([format[,epoch]])

VBScript/ASP

DateAdd("s", epoch, "01/01/1970 00:00:00")

AutoIT

_DateAdd("s", $EpochSeconds , "1970/01/01 00:00:00")

Delphi

myString := DateTimeToStr(UnixToDateTime(Epoch)); Where Epoch is a signed integer.

C

ts = *localtime(&rawtime); strftime(buf, sizeof(buf), "%a %Y-%m-%d %H:%M:%S %Z", &ts); printf("%s<br/>", buf);

Objective-C

NSDate * myDate = [NSDate dateWithTimeIntervalSince1970:epoch]; NSLog(@"%@", date);

R

as.POSIXct(epoch, origin="1970-01-01", tz="GMT")

Go

Example code

Adobe ColdFusion

DateAdd("s",epoch,"1/1/1970");

MySQL

FROM_UNIXTIME(epoch, optional output format) Default output format is YYY-MM-DD HH:MM:SS. If you need support for negative timestamps: DATE_FORMAT(DATE_ADD(FROM_UNIXTIME(0), interval -315619200 second),"%Y-%m-%d") (replace -315619200 with epoch)

PostgreSQL

PostgreSQL version 8.1 and higher: SELECT to_timestamp(epoch); Older versions: SELECT TIMESTAMP WITH TIME ZONE 'epoch' + epoch * INTERVAL '1 second';

SQLite

SELECT datetime(epoch_to_convert, 'unixepoch'); or local timezone: SELECT datetime(epoch_to_convert, 'unixepoch', 'localtime');

Oracle PL/SQL

SELECT to_date('01-JAN-1970','dd-mon-yyyy')+(1526357743/60/60/24) from dual Replace 1526357743 with epoch.

SQL Server

DATEADD(s, epoch, '1970-01-01 00:00:00')

IBM Informix

SELECT dbinfo('utc_to_datetime',epoch) FROM sysmaster:sysdual;

Microsoft Excel / LibreOffice Calc

(A1 / 86400) + 25569 Format the result cell for date/time, the result will be in GMT time (A1 is the cell with the epoch number). For other time zones: =((A1 +/- time zone adjustment) / 86400) + 25569.

Crystal Reports

DateAdd("s", {EpochTimeStampField}-14400, #1/1/1970 00:00:00#) -14400 used for Eastern Standard Time.

JavaScript

var myDate = new Date( your epoch date *1000); document.write(myDate.toGMTString()+"-------"+myDate.toLocaleString());

Tcl/Tk

clock format 1325376000 For More Tcl/Tk snippets

MATLAB

datestr(719529+TimeInSeconds/86400,'dd-mmm-yyyy HH:MM:SS')

IBM PureData System for Analytics

select 996673954::int4::abstime::timestamp;

Unix/Linux Shell

date -d @1520000000 Replace 1520000000 with your epoch, needs recent version of 'date'. Replace '-d' with '-ud' for GMT/UTC time.

Mac OS X

date -j -r 1520000000

PowerShell

Function get-epochDate ($epochDate) { [timezone]::CurrentTimeZone.ToLocalTime(([datetime]'1/1/1970').AddSeconds($epochDate)) } then use: get-epochDate 1520000000. Works for Windows PowerShell v1 and v2

Other OS's

Command line: perl -e "print scalar(localtime(epoch))" (If Perl is installed) Replace 'localtime' with 'gmtime' for GMT/UTC time.

How to get the current UNIX timestamp (epoch time) in each programming languages

Language

Syntax

PHP

time()

Python

import time; time.time()

Ruby

Time.now (or Time.new). To display the epoch: Time.now.to_i

Perl

time

Java

long epoch = System.currentTimeMillis()/1000; Returns epoch in seconds.

C#

DateTimeOffset.Now.ToUnixTimeSeconds() (.NET Framework 4.6+/.NET Core), older versions: var epoch = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds;

Objective-C

[[NSDate date] timeIntervalSince1970]; (returns double) or NSString *currentTimestamp = [NSString stringWithFormat:@"%f", [[NSDate date] timeIntervalSince1970]];

C++11

double now = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();

Lua

epoch = os.time([date])

VBScript/ASP

Now()

AutoIT

_DateDiff('s', "1970/01/01 00:00:00", _NowCalc())

Delphi

Epoch := DateTimetoUnix(Now); Tested in Delphi 2010.

R

as.numeric(Sys.time())

Erlang/OTP

int(parseDateTime(datetime).getTime()/1000); (version 18+), older versions: calendar:datetime_to_gregorian_seconds(calendar:universal_time())-719528*24*3600.

MySQL

SELECT unix_timestamp(now())

PostgreSQL

SELECT extract(epoch FROM now());

SQLite

SELECT strftime('%s', 'now');

SQL Server

SELECT DATEDIFF(s, '1970-01-01 00:00:00', GETUTCDATE())

Oracle PL/SQL

SELECT (CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - TO_DATE('01/01/1970','DD/MM/YYYY')) * 24 * 60 * 60 FROM DUAL;

IBM Informix

SELECT dbinfo('utc_current') FROM sysmaster:sysdual;

JavaScript

Math.floor(new Date().getTime()/1000.0) The getTime method returns the time in milliseconds.

Visual FoxPro

DATETIME() - {^1970/01/01 00:00:00} Warning: time zones not handled correctly

Go

time.Now().Unix()

Adobe ColdFusion

<cfset epochTime = left(getTickcount(), 10)>

Tcl/Tk

clock seconds

Unix/Linux Shell

date +%s

Solaris

/usr/bin/nawk 'BEGIN {print srand()}' Solaris doesn't support date +%s, but the default seed value for nawk's random-number generator is the number of seconds since the epoch.

PowerShell

[int][double]::Parse((Get-Date (get-date).touniversaltime() -UFormat %s))

Other OS's

Command line: perl -e "print time" (If Perl is installed on your system)

More than an Epoch UNIX Timestamp Converter

Rows is the easiest way to import, transform and share data in a spreadsheet.

Signup for free

Import data from anywhere

Unleash your data: import from files, marketing tools, databases, APIs, and other 3rd-party connectors.

Know more

Analyze with the power of AI

Unlock the power of AI on your data: ask the AI Analyst ✨ any question about your dataset and surface key insights, trends, and patterns.

Know more

Collaborate and Share

Seamlessly collaborate and share stunning reports with dynamic charts, embed options, and easy export features.

Know more