Unix timestamp 1776939848

About Unix Time

Unix time (also called Unix timestamp or POSIX time) is a simple way to represent a point in time as a single integer: the number of whole seconds that have passed since 1970-01-01 00:00:00 UTC, known as the Unix epoch.

Key facts

• 0 means 1970-01-01 00:00:00 UTC.
• Positive values are dates after the epoch, negative values are dates before it.
• Unix time does not know about time zones; it is always based on UTC.
• Most databases and APIs use Unix timestamps because they are compact and unambiguous.

The Year 2038 Problem

Some systems store epoch dates as a signed 32-bit integer, which might cause problems on January 19, 2038 (known as the Year 2038 problem or Y2038). The converter on this page converts timestamps in seconds (10-digit), milliseconds (13-digit) and microseconds (16-digit) to readable dates.

Get the current Unix time

On Linux, macOS, BSD (shell)

date +%s

Returns: 1776944651 (current Unix timestamp)

Convert a timestamp back to a date (shell)

date -d '@1776944651' -u

Returns: Thu Apr 23 11:44:11 2026 UTC

date -d '@1776944651'

Returns: Thu Apr 23 14:44:11 2026 (in your local timezone)

Unix time in common tools

MySQL - Get current timestamp

SELECT UNIX_TIMESTAMP(NOW());

Returns: 1776944651 (current Unix timestamp)

MySQL - Convert timestamp to date

SELECT FROM_UNIXTIME(1776944651);

Returns: 2026-04-23 14:44:11

PHP - Get current timestamp

$ts = time();

Returns: 1776944651 (current Unix timestamp)

PHP - Convert timestamp to UTC date

echo gmdate('Y-m-d H:i:s', $ts);

Returns: 2026-04-23 11:44:11 UTC

JavaScript - Get current timestamp

const ts = Math.floor(Date.now() / 1000);

Returns: 1776944651 (current Unix timestamp)

JavaScript - Convert timestamp to date

const d = new Date(ts * 1000);

Returns: Date object representing 2026-04-23T11:44:11Z

Python - Get current timestamp

import time
ts = int(time.time())

Returns: 1776944651 (current Unix timestamp)

Python - Convert timestamp to UTC date

import datetime
dt_utc = datetime.datetime.utcfromtimestamp(ts)

Returns: datetime object representing 2026-04-23 11:44:11 UTC

Node.js - Get current timestamp

const ts = Math.floor(Date.now() / 1000);

Returns: 1776944651 (current Unix timestamp)

Node.js - Convert timestamp to date

const d = new Date(ts * 1000);

Returns: Date object representing 2026-04-23T11:44:11Z

Where Unix time is used

Unix timestamps appear in almost every modern system. They are the default way to represent time in operating systems, web APIs, databases, mobile apps, monitoring tools and even blockchains.

Operating systems and files

Unix-like systems (Linux, BSD, macOS) track the current time internally as a Unix timestamp. File modification, access and creation times are stored as epoch-based integers that can be converted back to human dates on demand.

Web APIs and backends

Many public and internal HTTP APIs send and receive Unix timestamps for event times, rate limits, token expirations, scheduled jobs and analytics. Using a single UTC-based number avoids the confusion of time zones and daylight saving changes.

Databases and logs

Logging systems and databases often store timestamps either as Unix seconds or milliseconds. This makes it easy to sort, filter, aggregate and compare events over time without parsing complex date strings.

Mobile apps

val tsSeconds = System.currentTimeMillis() / 1000

Returns: 1776944651 (current Unix timestamp in Kotlin)

let ts = Int(Date().timeIntervalSince1970)

Returns: 1776944651 (current Unix timestamp in Swift)

Mobile SDKs rely on Unix time for sync, caching, notifications, analytics and offline data. The timestamp can be safely sent to servers, stored locally or embedded in API calls.

Crypto and blockchain

uint256 nowTs = block.timestamp;

Returns: 1776944651 (current block timestamp in Solidity)

Blockchains record the time of each block and transaction using epoch-based values. Smart contracts use these timestamps to implement locks, vesting schedules, auctions and time-based conditions.

Monitoring, metrics and IoT

Monitoring tools, metrics collectors and IoT devices use Unix timestamps to tag measurements and events. This allows dashboards and alerting systems to align data from different sources on a single time axis.

Why use UnixDate?

• Paste any Unix timestamp and instantly see what date and time it represents.
• Generate timestamps from calendar dates for quick debugging or API calls.
• Open a direct URL like /1776944651 to share or bookmark a specific moment.
• Compare the same Unix time across multiple time zones with the live clocks above.

What makes UnixDate different?

Most timestamp converters simply print a date and stop there. UnixDate aims to be a complete, precise and developer-friendly tool. Every timestamp page is generated dynamically and includes fully formatted UTC and local time, ISO 8601 strings, weekday information, day of year, and a live "relative to now" counter that updates every second.

Along with that, UnixDate provides live world clocks for major cities, automatic detection of milliseconds, and shareable clean URLs for every timestamp. It works equally well for quick copy-paste lookups and for serious debugging work.

Milliseconds and sub-second precision

Many modern APIs and browsers use millisecond Unix timestamps instead of seconds. UnixDate detects this automatically: if the value contains more than 10 digits it is treated as a millisecond timestamp and converted accordingly. Both the normalized second value and the original millisecond value are shown on timestamp pages and in the JSON API.

UnixDate JSON API

UnixDate exposes a simple, stateless JSON API so you can integrate timestamp conversions in scripts, cron jobs, monitoring systems or backend services. No keys, no authentication.

API endpoint

https://unixdate.com/api/<timestamp>

Use the current timestamp in your tools

Shell (curl + date)

ts=$(date +%s)
curl "https://unixdate.com/api/$ts"

Returns: JSON response with timestamp details

JavaScript / Node.js

const ts = Math.floor(Date.now() / 1000);
fetch("https://unixdate.com/api/" + ts)
.then(r => r.json())
.then(data => {
console.log("UTC:", data.utc.human);
console.log("Local:", data.local.human);
});

Returns: JSON response with timestamp details

Example JSON response for the current timestamp

{
    "ok": true,
    "input": "1776939848",
    "serverNow": 1776944651,
    "interpretedUnit": "s",
    "unix": {
        "seconds": 1776939848,
        "milliseconds": 1776939848000
    },
    "utc": {
        "human": "2026-04-23 10:24:08 UTC",
        "iso8601": "2026-04-23T10:24:08Z"
    },
    "local": {
        "timezone": "Europe\/Helsinki",
        "human": "2026-04-23 13:24:08",
        "iso8601": "2026-04-23T13:24:08"
    },
    "relativeToServerNow": "1 hours ago"
}

UnixDate JSON API

Use UnixDate as a simple, stateless JSON API. No keys, no auth. Send a timestamp in the URL and get UTC, ISO 8601, local time, and a relative description.

Endpoints

• Current time: GET /api/now
• Specific timestamp: GET /api/<timestamp> (seconds)
• Root: GET /api (alias of now)

Examples

curl -s "https://unixdate.com/api/now"

curl -s "https://unixdate.com/api/1700000000"

Response fields

• unix.seconds and unix.milliseconds
• utc.human and utc.iso8601
• local.human and local.iso8601 (server timezone)
• relativeToServerNow (e.g. “3 hours ago”)

Notes

• Inputs are interpreted as seconds.
• If you use milliseconds, convert to seconds first (divide by 1000).
• The local section uses the server timezone: Europe/Helsinki.

Common Time Intervals in Seconds

Understanding common time intervals helps when working with Unix timestamps for scheduling, caching, or data retention periods.

Unix time in programming languages, databases and tools

Almost every language, database and platform has built-in support for Unix timestamps. Below are comprehensive examples for getting the current Unix time and converting between epoch and human-readable dates.

time()

import time; time.time()

Time.now.to_i

time

long epoch = System.currentTimeMillis() / 1000;

DateTimeOffset.Now.ToUnixTimeSeconds()

[[NSDate date] timeIntervalSince1970]

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

os.time()

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

DateTimeToUnix(Now)

DateTime.now().millisecondsSinceEpoch ~/ 1000

as.numeric(Sys.time())

erlang:system_time(seconds)

SELECT UNIX_TIMESTAMP(NOW())

SELECT EXTRACT(EPOCH FROM NOW())

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

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

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

SELECT dbinfo('utc_current') FROM sysmaster:sysdual

Math.floor(Date.now() / 1000)

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

time.Now().Unix()

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

clock seconds

date +%s

/usr/bin/nawk 'BEGIN {print srand()}'

[DateTimeOffset]::UtcNow.ToUnixTimeSeconds()

perl -e "print time"

strtotime("2026-04-23 14:44:11")

import calendar, time
calendar.timegm(time.strptime('2026-04-23 14:44:11', '%Y-%m-d %H:%M:%S'))

Time.gm(2026, 4, 23, 14, 44, 11).to_i

new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2026-04-23 14:44:11").getTime() / 1000

SELECT UNIX_TIMESTAMP('2026-04-23 14:44:11')

SELECT EXTRACT(EPOCH FROM TIMESTAMP '2026-04-23 14:44:11')

SELECT strftime('%s', '2026-04-23 14:44:11')

SELECT DATEDIFF(s, '1970-01-01 00:00:00', '2026-04-23 14:44:11')

Math.floor(new Date('2026-04-23T14:44:11Z').getTime() / 1000)

date -d "2026-04-23 14:44:11" +%s

date('Y-m-d H:i:s', 1776944651)

import datetime
datetime.datetime.utcfromtimestamp(1776944651).strftime('%Y-%m-d %H:%M:%S')

Time.at(1776944651).utc.strftime('%Y-%m-d %H:%M:%S')

new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new java.util.Date(1776944651 * 1000L))

SELECT FROM_UNIXTIME(1776944651)

SELECT TO_TIMESTAMP(1776944651)

SELECT datetime(1776944651, 'unixepoch')

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

new Date(1776944651 * 1000).toISOString().replace('T', ' ').replace(/\..*/, '')

date -d @1776944651 -u