| Unix timestamp (seconds) | 1,400,000,000 |
|---|---|
| In milliseconds | 1,400,000,000,000 |
| UTC date & time | Tuesday, May 13, 2014, 16:53:20 UTC |
| Day of week (UTC) | Tuesday |
| ISO 8601 | 2014-05-13T16:53:20Z |
| RFC 2822 | Tue, 13 May 2014 16:53:20 +0000 |
| Your local time | — |
| Day of year | Day 133 of 2014 (365 days) |
| ISO week | 2014-W20 |
| Days since epoch | 16,203 full days + 60,800 seconds |
| Julian Date | JD 2456791.20370 |
| Hexadecimal | 0x53724E00 |
| Binary (32-bit) | 01010011 01110010 01001110 00000000 |
| Read as milliseconds | Saturday, January 17, 1970, 04:53:20 UTC — the classic off-by-1000 mistake |
| 32-bit signed | Fits in a signed 32-bit integer with 747,483,647 seconds (23 years, 250 days) to spare before the 2038 limit. |
| Previous milestone | 1300000000 (Round Timestamp 1.3 Billion) is 1,157.4 days earlier |
| Next milestone | 1500000000 (Round Timestamp 1.5 Billion) is 1,157.4 days later |
What does the timestamp 1400000000 mean?
1,400,000,000 is one of those round, memorable Unix timestamps developers actually notice. It marks the round-number timestamp 1,400,000,000, landing on Tuesday, May 13, 2014 at 16:53:20 UTC. Below is everything you need to read, convert, and reuse this exact value.
Another tidy reference value, 1,400,000,000 is frequently used in tutorials and test fixtures because it is easy to type and remember while still pointing at a realistic modern date.
Why 1400000000 matters
1,400,000,000 arrived at 16:53:20 UTC on Tuesday, May 13, 2014, about five weeks after the Heartbleed vulnerability in OpenSSL was disclosed, in a spring when a great many servers were being patched and certificates reissued. If you are reading old incident logs, that context helps: any ten-digit timestamp that begins with 14 was recorded between May 13, 2014 and July 14, 2017, when the leading digits ticked over to 15. The value sits at roughly 65 percent of the signed 32-bit range, leaving 23 years, 250 days before the 2038 limit. Its real popularity, though, comes from test fixtures and seed data. A timestamp with a memorable shape is easy to type into a fixture, easy to spot in a diff, and, being a round hundred-million, has the pleasant property that its milliseconds form, 1,400,000,000,000, is just as recognisable. That symmetry is also its most common failure mode: seed a database with the seconds value, read it back through a library that expects milliseconds, and every row appears to have been created on January 17, 1970.
The exact value, every way you need it
A Unix timestamp is a single integer: the count of seconds elapsed since the Unix epoch (midnight UTC on January 1, 1970), ignoring leap seconds. The value 1,400,000,000 seconds is the same instant as 1,400,000,000,000 milliseconds — the form most programming languages expect, since JavaScript, Java, and many databases store time in milliseconds. Written out in full it is Tuesday, May 13, 2014 at 16:53:20 UTC, which is a Tuesday. In the two most common machine-readable formats it is 2014-05-13T16:53:20Z (ISO 8601) and Tue, 13 May 2014 16:53:20 +0000 (RFC 2822). All of these describe one and the same moment in time; they differ only in notation.
How to convert 1400000000 in code
Turning this timestamp into a human-readable date takes a single expression in most languages. In JavaScript, remember to multiply by 1000 because Date works in milliseconds: new Date(1400000000 * 1000).toUTCString(). Here are the equivalents in three common environments:
// JavaScript const ts = 1400000000; const date = new Date(ts * 1000); // JS uses milliseconds console.log(date.toUTCString()); // Tue, 13 May 2014 16:53:20 GMT console.log(date.toISOString()); // 2014-05-13T16:53:20Z
# Python 3 from datetime import datetime, timezone ts = 1400000000 print(datetime.fromtimestamp(ts, tz=timezone.utc)) # 2014-05-13 16:53:20+00:00
# Bash / GNU date date -u -d @1400000000 # Tue, 13 May 2014 16:53:20 UTC # macOS / BSD date date -u -r 1400000000
If you would rather not write code at all, the Epoch Converter is pre-loaded with 1400000000 so you can see it converted instantly and tweak the value live.
How long ago (or how far away) is it?
The headline near the top of this page updates every time you load it, computing the gap between 1400000000 and your current clock in real time so it never goes stale. To measure the span between this timestamp and any other date precisely — in years, months, weeks, days, or business days — use the Date Duration Calculator. To watch a future moment tick down second by second, the Countdown Timer can target this exact instant.
Why timestamps matter
Storing time as a plain integer of seconds is wonderfully unambiguous: there is no time zone, no daylight saving, and no locale to misinterpret. Two servers anywhere on Earth agree on what 1400000000 means. That is why logs, databases, JWTs, file metadata, and APIs lean on Unix time so heavily. The trade-off is that the number is not human-friendly at a glance — which is exactly the gap a reference like this page fills.
Related timestamps
Other notable Unix timestamps worth a look:
- 1234567890 — The 1234567890 Timestamp1300000000 — Round Timestamp 1.3 Billion1500000000 — Round Timestamp 1.5 Billion1577836800 — Start of 2020