Epoch Converter Functions and Routines

Index

In the examples on this page, 1800000000 is used as an example epoch time. Replace it with your own value to convert it.

Current programming languages, OSes and databases

Legacy / EOL

AutoIT routines

Get current epoch (seconds):

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

Convert human-readable date to epoch:

_DateDiff('s', "1970/01/01 00:00:00", "YYYY/MM/DD HH:MM:SS")

Convert epoch to human-readable date:

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

C# routines

Get current epoch (seconds):

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;

Convert epoch to human-readable date:

private string epoch2string(int epoch) {
return new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds(epoch).ToShortDateString(); }

C++ routines

Get current epoch (seconds):

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

Dart routines

Get current epoch:

DateTime.now().millisecondsSinceEpoch ~/ 1000

In microseconds:

DateTime.now().microsecondsSinceEpoch

Convert epoch to human-readable date:

DateTime.fromMillisecondsSinceEpoch(1800000000*1000)

Delphi routines

Get current epoch (seconds):

Epoch := DateTimeToUnix(Now, False);

There is also a DateTimeToMillisecondsSince1970 function.

Convert human-readable date to epoch:

Epoch := DateTimeToUnix(StrToDateTime(myString));

Convert epoch to human-readable date:

myString := DateTimeToStr(UnixToDateTime(Epoch));

Where Epoch is a signed integer.

Erlang/OTP routines

Get current epoch (seconds):

erlang:system_time(seconds).

Go routines

package main

import (
    "fmt"
    "time"
)

func main() {
    // Current epoch time
    fmt.Printf("Current epoch time is:\t\t\t%d\n\n", currentEpochTime())

    // Convert from human-readable date to epoch
    humanReadable := time.Now()
    fmt.Printf("Human-readable time is:\t\t\t%s\n", humanReadable)
    fmt.Printf("Human-readable to epoch time is:\t%d\n\n", humanReadableToEpoch(humanReadable))

    // Convert from epoch to human-readable date
    epoch := currentEpochTime()
    fmt.Printf("Epoch to human-readable time is:\t%s\n", epochToHumanReadable(epoch))
}

func currentEpochTime() int64 {
    return time.Now().Unix()
    // time.Now().UnixMilli() for milliseconds
}

func humanReadableToEpoch(date time.Time) int64 {
    return date.Unix()
}

func epochToHumanReadable(epoch int64) time.Time {
    return time.Unix(epoch, 0)
}

Groovy/Jenkins routines

Get current epoch (seconds):

System.currentTimeMillis() / 1000

Convert epoch to human-readable date:

import java.time.Instant
import java.time.ZoneId
import java.time.format.DateTimeFormatter

long unixTimestamp = 1800000000L

def instant = Instant.ofEpochSecond(unixTimestamp)

def formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss")
    .withZone(ZoneId.of("Europe/London"))

println "Readable date: ${formatter.format(instant)}"

Java routines

Get current epoch (seconds):

long epoch = System.currentTimeMillis()/1000;

Returns epoch in seconds.

Convert human-readable date to epoch:

long epoch = new java.text.SimpleDateFormat("MM/dd/yyyy HH:mm:ss").parse("01/01/1970 01:00:00").getTime() / 1000;

Timestamp in seconds, remove '/1000' for milliseconds.

Convert epoch to human-readable date:

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.

JavaScript routines

Get current epoch (in seconds):

Math.floor(new Date().getTime()/1000.0)

Convert an epoch to human-readable date:

Example with epoch date '123': 
var myDate = new Date(123*1000);
document.write(myDate.toUTCString()+"<br>"+myDate.toLocaleString());

The example above gives the following output (with epoch date 123):

You can also use getFullYear, getMonth, getDay, etc. See documentation below.

Convert human-readable dates to epoch:

var myDate = new Date("July 1, 1978 02:30:00"); // Your timezone!
var myEpoch = myDate.getTime()/1000.0;
document.write(myEpoch);

The example above gives the following output:

There are many ways to create dates in JavaScript (for example with setFullYear, setMonth, setDay, etc.).
More about the JavaScript Date object.

Lua routines

Get current epoch (seconds):

epoch = os.time([date])

Convert epoch to human-readable date:

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

macOS command

Get current epoch (seconds):

date -j

Convert epoch to human-readable date:

date -j -r 1800000000

MATLAB routines

Convert epoch to human-readable date:

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

Microsoft Excel / LibreOffice Calc

Convert epoch to human-readable date:

=(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

Find the time zone adjustment in seconds for your time zone on the time zones list page.

Objective-C routines

Get current epoch (seconds):

[[NSDate date] timeIntervalSince1970];

Returns a double. To get a string:

NSString *currentTimestamp = [NSString stringWithFormat:@"%f", [[NSDate date] timeIntervalSince1970]];

Convert epoch to human-readable date:

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

Oracle PL/SQL routines

Get current epoch (seconds):

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

Convert epoch to human-readable date:

SELECT to_date('01-JAN-1970','dd-mon-yyyy')+(1800000000/60/60/24) from dual

Replace 1526357743 with epoch.

PostgreSQL routines

Get current epoch (seconds):

SELECT extract(epoch FROM now());

Convert human-readable date to epoch:

SELECT extract(epoch FROM date('2000-01-01 12:34'));

With timestamp:

SELECT EXTRACT(EPOCH FROM TIMESTAMP WITH TIME ZONE '2018-02-16 20:38:40-08');

With interval:

SELECT EXTRACT(EPOCH FROM INTERVAL '5 days 3 hours');

Convert epoch to human-readable date:

PostgreSQL version 8.1 and higher:

SELECT to_timestamp(1800000000);

Older versions:

SELECT TIMESTAMP WITH TIME ZONE 'epoch' + 1800000000 * INTERVAL '1 second';

PowerShell routines

Get current epoch (seconds):

 [DateTimeOffset]::Now.ToUnixTimeSeconds()

or:

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

Convert epoch to human-readable date:

PowerShell 5.1+ (Windows 10+):

 [DateTimeOffset]::FromUnixTimeSeconds(1800000000).LocalDateTime

PowerShell Core (7.0+):

Get-Date -UnixTimeSeconds 1800000000

Version for all Windows PowerShell versions:

Function get-epochDate ($epochDate) {
  [timezone]::CurrentTimeZone.ToLocalTime(([datetime]'1/1/1970').AddSeconds($epochDate))  }

get-epochDate 1800000000

Python routines

Get current epoch (seconds):

import time;
time.time()

Convert human-readable date to epoch:

import calendar, time;
calendar.timegm(time.strptime('2000-01-01 12:34:00', '%Y-%m-%d %H:%M:%S'))

Convert epoch to human-readable date:

import time; time.ctime(1800000000)
Or: 
import time;
time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime(1800000000))

Replace time.localtime with time.gmtime for GMT time. Or using datetime:
import datetime; datetime.datetime.utcfromtimestamp(epoch).replace(tzinfo=datetime.timezone.utc)

R routines

Get current epoch (seconds):

as.numeric(Sys.time())

Convert human-readable date to epoch:

as.numeric(as.POSIXct("YYYY-MM-dd HH:mm:ss", tz = "GMT", origin="1970-01-01"))

The origin parameter is optional.

Convert epoch to human-readable date:

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

Ruby routines

Get current epoch (seconds):

Time.now

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

Convert human-readable date to epoch:

Time.local(year, month, day, hour, minute, second, usec)

(or Time.gm for GMT/UTC input). To display add .to_i

Convert epoch to human-readable date:

Time.at(epoch)

Rust routines

Get current epoch / convert human-readable date to epoch:

SystemTime::now().duration_since(SystemTime::UNIX_EPOCH)

SystemTime documentation

SQL Server routines

Get current epoch (seconds):

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

Convert human-readable date to epoch:

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

Convert epoch to human-readable date:

SELECT DATEADD(s, 1800000000, '1970-01-01 00:00:00');

Replace s with ms if the epoch is in milliseconds.

SQLite routines

Get current epoch (seconds):

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

Convert human-readable date to epoch:

SELECT strftime('%s', timestring);

Convert epoch to human-readable date:

SELECT datetime(1800000000, 'unixepoch');

Or local time zone:

SELECT datetime(1800000000, 'unixepoch', 'localtime');

Tcl/Tk routines

Get current epoch (seconds):

clock seconds

Convert epoch to human-readable date:

clock format 1800000000

See Tcl/Tk clock documentation for more details.

Unix/Linux Shell (Bash) commands

Get current epoch (seconds):

date +%s

Convert human-readable date to epoch:

date +%s -d"Jan 1, 1980 00:00:01"

Replace '-d' with '-ud' to input in GMT/UTC time.

Convert epoch to human-readable date:

date -d @1800000000

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

 

Legacy / EOL

Adobe ColdFusion routines

Get current epoch (seconds):

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

Convert human-readable date to epoch:

int(parseDateTime(datetime).getTime()/1000);

Convert epoch to human-readable date:

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

ASP / VBScript routines

Warning! You need to correct the time zone for these examples to work.

A manual quick fix is to either:

  • look up the offset in wmi and add it to Now()
  • change the "01/01/1970 00:00:00" string, for example for GMT/UTC+1 = "01/01/1970 01:00:00"

The current Unix time:

' check time zone
DateDiff("s", "01/01/1970 00:00:00", Now())

Current Unix time with time zone fix:

function date2epoch(myDate)
Set dateTime = CreateObject("WbemScripting.SWbemDateTime")
dateTime.SetVarDate (myDate)
DateDiff("s", "01/01/1970 00:00:00", CDate(dateTime.GetVarDate (false)))
end function

Wscript.echo date2epoch(Now())

date2epoch converts a VBScript date to a Unix timestamp:

' check time zone if your date is not GMT/UTC
function date2epoch(myDate)
date2epoch = DateDiff("s", "01/01/1970 00:00:00", myDate)
end function

Usage example:

date2epoch(Now())

epoch2date converts Unix timestamps back to VBScript dates:

' result is GMT/UTC
function epoch2date(myEpoch)
epoch2date = DateAdd("s", myEpoch, "01/01/1970 00:00:00")
end function

Crystal Reports routines

Convert epoch to human-readable date:

DateAdd("s", {EpochTimeStampField}-14400, #1/1/1970 00:00:00#)

-14400 used for Eastern Standard Time. See Time Zones.

IBM Informix routines

Get current epoch (seconds):

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

Convert epoch to human-readable date:

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

IBM PureData System for Analytics routines

Convert epoch to human-readable date:

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

Solaris (OS commands)

Get current epoch (seconds):

/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.

Visual FoxPro routines

Get current epoch (seconds):

DATETIME() - {^1970/01/01 00:00:00}

Warning: time zones may not be handled correctly by Visual FoxPro.

 

Thanks to everyone who sent corrections and updates!

Pages

Home
Toggle theme Dark theme