Unix Timestamp 1700000000

1700000000
Round Timestamp 1.7 Billion — Tuesday, November 14, 2023, 22:13:20 UTC
Calculating how long ago that was…
Open in the Epoch Converter → Measure a date duration
Unix timestamp (seconds)1,700,000,000
In milliseconds1,700,000,000,000
UTC date & timeTuesday, November 14, 2023, 22:13:20 UTC
Day of week (UTC)Tuesday
ISO 86012023-11-14T22:13:20Z
RFC 2822Tue, 14 Nov 2023 22:13:20 +0000
Your local time
Day of yearDay 318 of 2023 (365 days)
ISO week2023-W46
Days since epoch19,675 full days + 80,000 seconds
Julian DateJD 2460263.42593
Hexadecimal0x6553F100
Binary (32-bit)01100101 01010011 11110001 00000000
Read as millisecondsTuesday, January 20, 1970, 16:13:20 UTC — the classic off-by-1000 mistake
32-bit signedFits in a signed 32-bit integer with 447,483,647 seconds (14 years, 65 days) to spare before the 2038 limit.
Previous milestone1672531200 (Start of 2023) is 317.9 days earlier
Next milestone1735689600 (Start of 2025) is 413.1 days later

What does the timestamp 1700000000 mean?

1,700,000,000 is one of those round, memorable Unix timestamps developers actually notice. It marks the round-number timestamp 1,700,000,000, landing on Tuesday, November 14, 2023 at 22:13:20 UTC. Below is everything you need to read, convert, and reuse this exact value.

When Unix time crossed 1.7 billion in November 2023, it was a small but widely-noted milestone. Each 100-million-second step covers a little over three years, so these markers make handy mental yardsticks.

Why 1700000000 matters

1.7 billion seconds arrived at 22:13:20 UTC on Tuesday, November 14, 2023, and was greeted with the usual flurry of terminal screenshots on social media. It is the most recent hundred-million rollover at the time of writing, and the next, 1.8 billion, is due on January 15, 2027. Every timestamp that begins with 17 belongs to the window between those two dates, which is a handy way to eyeball whether a log line is current. The value sits about 79 percent of the way through the signed 32-bit range, with 14 years, 65 days of headroom left, and it is 19,675 full days after the epoch. Hundred-million steps make a good mental yardstick precisely because each one is 3.17 years long: two steps are a little over six years, three are almost a decade. A common exercise for people learning Unix time is to memorise a few of these anchors (1.0 billion in 2001, 1.5 billion in 2017, 1.7 billion in 2023) and interpolate everything else, which turns out to be accurate to within a few months without a calculator.

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,700,000,000 seconds is the same instant as 1,700,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, November 14, 2023 at 22:13:20 UTC, which is a Tuesday. In the two most common machine-readable formats it is 2023-11-14T22:13:20Z (ISO 8601) and Tue, 14 Nov 2023 22:13:20 +0000 (RFC 2822). All of these describe one and the same moment in time; they differ only in notation.

How to convert 1700000000 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(1700000000 * 1000).toUTCString(). Here are the equivalents in three common environments:

// JavaScript
const ts = 1700000000;
const date = new Date(ts * 1000);   // JS uses milliseconds
console.log(date.toUTCString());    // Tue, 14 Nov 2023 22:13:20 GMT
console.log(date.toISOString());    // 2023-11-14T22:13:20Z
# Python 3
from datetime import datetime, timezone
ts = 1700000000
print(datetime.fromtimestamp(ts, tz=timezone.utc))
# 2023-11-14 22:13:20+00:00
# Bash / GNU date
date -u -d @1700000000
# Tue, 14 Nov 2023 22:13:20 UTC

# macOS / BSD date
date -u -r 1700000000

If you would rather not write code at all, the Epoch Converter is pre-loaded with 1700000000 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 1700000000 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 1700000000 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: