How Many Days Has It Been Since September 19th

How Many Days Has It Been Since September 19th? Here's How to Calculate It

There's something almost meditative about counting days. Maybe you're trying to remember how long ago a life event happened. Maybe you're tracking a project milestone. Or maybe you just woke up one morning thinking, "wait, how many days has it actually been since September 19th?

Whatever brought you here, you're not looking for a vague answer. You want precision. And honestly, most search results will just give you a number that changes every single day — which isn't all that useful a week from now.

That's why this guide is different. Instead of handing you a number that expires tomorrow, I'm going to show you how to calculate it yourself, explain the gotchas that trip most people up, and give you the mental tools to handle any date calculation that comes your way.

Sound good? Let's get into it.

What Does "Days Since September 19th" Actually Mean?

Here's the thing — when most people ask "how many days since September 19th," they're asking one of two things:

1. The inclusive count — they're counting September 19th itself as day one.
2. The exclusive count — they want to know how many full 24-hour periods have passed since that date ended.

These produce different results, and it's why you sometimes see conflicting answers online.

Here's one way to look at it: if today is September 22nd:

• Inclusive counting: September 19th, 20th, 21st, 22nd = 4 days
• Exclusive counting: September 20th, 21st, 22nd = 3 days

Most date calculators use the exclusive method — they count forward from the day after* the start date to the current date. But honestly? Both approaches have merit depending on context.

Why a Specific Date Like September 19th?

September 19th isn't random either. For many people, this date carries significance:

• It might be a birthday (someone else's or your own)
• A wedding anniversary
• The day something important happened — good or bad
• A milestone in a project or endeavor

When a date matters to you, precision starts to matter too. "A while ago" doesn't cut it anymore.

Why Knowing the Exact Day Count Actually Matters

You might think this is just curiosity, but there are real practical reasons people need accurate day counts:

Legal and contractual contexts. Many contracts specify deadlines in days rather than dates. Understanding exactly how many days have passed (or remain) can be the difference between honoring an agreement or missing a window.

Health and fitness tracking. If you're doing a 30-day challenge that started on September 19th, you need to know what day you should be on. Guess wrong and you're either cheating yourself or falling behind.

Financial calculations. Interest accrual, billing cycles, and payment due dates often hinge on exact day counts. The difference between 30 and 31 days can mean dollars in some contexts.

Personal reflection. Some people like to mark time after significant events — whether that's a sobriety milestone, days since a bad habit, or simply wanting to mark how long it's been since something changed in their life.

Here's what most people miss: the method you use to count matters as much as the math. More on that in a moment.

How to Calculate Days Since September 19th

There are a few different approaches, and the right one depends on your needs and how precise you need to be.

Method 1: Manual Calendar Counting

The old-fashioned way. Grab a calendar and count:

1. Find September 19th
2. Count each day forward from September 20th (if you want the exclusive count)
3. Stop when you reach today

This works fine for short periods — maybe 30 days or less. Beyond that, it gets tedious and error-prone.

Method 2: The Math Approach

For those who like formulas:

Step 1: Convert both dates to a "day number" — essentially how many days have passed since a fixed reference point (like January 1, 0001).

Step 2: Subtract the start date from the end date.

The result = your day count

You can do this with a spreadsheet, or by using what programmers call the "Julian Day" approach. Most spreadsheet programs (Excel, Google Sheets) will handle this automatically with a simple formula.

In Excel: =TODAY() - DATE(2024,9,19) (adjust the year as needed)

In Google Sheets: Same formula, works the same way.

This gives you the number of days between the dates, which is exactly what you're looking for.

Method 3: Online Date Calculators

There are dozens of free date calculators online. Most will let you input two dates and get the difference instantly.

But here's my practical tip: don't rely on a static answer from a search result. If you're reading this article on any date after it was published, a result that says "it's been X days" is probably wrong for today.

Instead, use a calculator that gives you a live result — or better yet, learn to calculate it yourself using Method 2.

The Leap Year Factor

This is where it gets tricky, and where most people make mistakes.

September 19th falls in a month that comes before* February. So if you're calculating days since September 19th of one year to September 19th of the next, and there's a February 29th in between, that year has 366 days instead of 365.

Most date calculators handle this automatically. But if you're doing manual math or writing a spreadsheet formula, you need to account for leap years.

The rule: A year is a leap year if it's divisible by 4, except for years divisible by 100 — unless those are also divisible by 400.

So 2024 is a leap year. Even so, good. 2024 ÷ 4 = 506 with no remainder. 2024 is not divisible by 100, so it passes that test too.

If you're counting across the leap day boundary, you need to decide whether to include February 29th in your count. For most purposes, you do — it was a real day that happened.

Common Mistakes People Make

I've seen these trip up even smart people, so let's clear them up now.

Including both endpoints. Trying to count "from September 19th to September 20th" sometimes makes people say 2 days, when it's actually just 1 full day. September 19th to September 20th = 1 day has passed.

Ignoring time zones. If you say "it's been exactly X days since September 19th at 3 PM," that only makes sense if you know what time zone you're measuring from. For day counts without a specific time, assume midnight-to-midnight.

Assuming every year has 365 days. Leap years throw off any calculation that

Mistake #4 – Ignoring Leap Years in Multi‑Year Gaps

When you’re measuring a span that crosses several years, it’s easy to assume each year contributes exactly 365 days. In reality, every year that meets the leap‑year rule adds an extra day.

How to fix it:

1. Count the full years between the start and end dates.
2. Add the leap‑day count for those years.
   • A year is a leap year if (year % 4 == 0) and (year % 100 != 0 or year % 400 == 0).
   • Loop through each year in the range and tally the leap years.
3. Add the remaining days in the partial year at the start and end (using a month‑day table that already knows how many days each month has, including February 29 for leap years).

Quick Python snippet (works for any Gregorian dates):

from datetime import date

def days_between(start: date, end: date) -> int:
    # datetime handles leap years automatically
    delta = end - start
    return abs(delta.days)

# Example: 19 Sep 2023 → 19 Sep 2025
start = date(2023, 9, 19)
end   = date(2025, 9, 19)
print(days_between(start, end))   # → 731  (includes the leap day of 2024)

If you prefer a spreadsheet, the built‑in DATEDIF function already respects leap years:

=DATEDIF(A2, B2, "d")

where A2 holds the start date and B2 the end date.

---

Putting It All Together – A Mini‑Workflow

1. Identify the two dates (including year, month, day).
2. Choose your tool:
   • Spreadsheet*: =TODAY() - DATE(y,m,d) (or DATEDIF).
   • Programming*: use the language’s date library (datetime, moment.js, etc.).
   • Online calculator*: pick one that updates dynamically.
3. Validate the result:
   • Verify that the day count matches a manual sanity check for a short interval (e.g., yesterday should be 1 day).
   • For multi‑year spans, ensure the total is either 365 × years + leap‑day count or matches a trusted calculator.
4. Document the calculation: note the method and any assumptions (time zone, inclusion/exclusion of endpoints) for future reference.

---

Final Checklist – Have I Got It Right?

• [ ] Both dates are in the same calendar system (Gregorian, Julian, etc.).
• [ ] The calculation accounts for leap years when spanning February 29.
• [ ] End‑points are handled consistently (usually exclude* the start date, include* the end date).
• [ ] Time‑zone issues are resolved (use midnight‑to‑midnight if no specific time is given).
• [ ] The tool you used updates automatically (or you recomputed manually).

---

Conclusion

Counting days between two dates seems trivial, but hidden complexities—leap years, off‑by‑one errors, and time‑zone nuances—can easily skew the result. With these safeguards in place, you’ll never be caught guessing how many days have truly elapsed. Consider this: remember to double‑check your work, especially when the span crosses a February 29, and always be explicit about whether you’re including or excluding the start and end dates. By leveraging modern spreadsheet functions, built‑in date libraries, or reliable online calculators, you can obtain an accurate day count with minimal effort. Happy calculating!

For more on this topic, read our article on how many days until may 9th or check out how to find range of a data set.

Beyond the Basics – Real‑World Considerations

While counting calendar days is straightforward, many practical situations introduce extra constraints. Below are common extensions you’ll encounter in business, finance, and scientific work, together with concise ways to handle them.

1. Business‑Day Calculations

In many contexts you need to exclude weekends and public holidays.

Excel / Google Sheets

=NETWORKDAYS(A2, B2, holidays_range)

NETWORKDAYS returns the number of working days between two dates, optionally subtracting a list of holidays stored in a separate range.

Python (pandas)

import pandas as pd
from pandas.tseries.offsets import CustomBusinessDay

start = pd.Timestamp('2023-09-19')
end   = pd.Timestamp('2025-09-19')
bday   = CustomBusinessDay(holidays=pd.

# Count business days between the two dates (inclusive of end)
biz_days = np.busday_count(start.date(), end.date())
# Or, to get a list of all business days:
business_dates = pd.date_range(start, end, freq=bday)

R

library(bizdays)
load_rmetrics_calendars(2020)   # uses RMetrics holiday calendar
bizdays("2023-09-19", "2025-09-19", cal="Rmetrics")

Tip: When specifying holidays, always verify that they match the jurisdiction you care about (e.g.So , US federal vs. state‑specific).

2. Cross‑Calendar Differences

If you work with historical dates or cultures that still use the Julian calendar, you’ll need to convert between systems.

Python (using astropy)

from astropy.time import Time

jd = Time('2023-09-19', scale='utc')   # defaults to Gregorian (ISO)
print(jd.jd)        # Julian Date

### 3. Time‑Zone Handling and Day‑light‑Saving Transitions  

When a span straddles a time‑zone boundary or a daylight‑saving (DST) change, a naïve “midnight‑to‑midnight” count can be off by an hour or even a whole day.  

**Excel / Google Sheets**  
```excel
=DAYS(A2+TIME(0,0,0),B2+TIME(0,0,0))   // works as long as both cells are stored as datetime with timezone

If the cells contain text, you must first convert them with DATEVALUE and TIMEVALUE while specifying the zone (Excel stores no time‑zone info, so you must manually adjust).

Python (using pytz or zoneinfo)

from datetime import datetime, timedelta
from zoneinfo import ZoneInfo   # Python 3.9+

tz_ny = ZoneInfo("America/New_York")
tz_la = ZoneInfo("America/Los_Angeles")

start = datetime(2024, 3, 9, 12, 0, tzinfo=tz_ny)   # DST starts in NY
end   = datetime(2024, 3, 10, 12, 0, tzinfo=tz_la)  # LA is PST (UTC‑8)

# Convert both to UTC to get an accurate day count
start_utc = start.astimezone(ZoneInfo("UTC"))
end_utc   = end.astimezone(ZoneInfo("UTC"))

delta_days = (end_utc.date() - start_utc.date()).days
print(delta_days)   # 1

R (using lubridate)

library(lubridate)
with_tz(ymd_hms("2024-03-09 12:00:00", tz = "America/New_York"),
        "UTC") %--%
with_tz(ymd_hms("2024-03-10 12:00:00", tz = "America/Los_Angeles")) %>%
  as.duration() %>%
  as.numeric("days")

Tip: Always store timestamps with an explicit time‑zone (or UTC) and only convert to local time for display. This eliminates ambiguity when counting calendar days across DST boundaries.

---

4. Fiscal Year and Accounting Period Calculations

Many organizations define their fiscal year differently (e.g.Which means , July 1 – June 30). When you need the number of days between two dates within* a specific fiscal period, you can combine date arithmetic with period masks.

Excel (using helper columns)

1. Add a column that returns the fiscal year for each date: =YEAR(A2)+(MONTH(A2)>6).
2. Use a SUMPRODUCT to count days that fall inside a given fiscal year:

=SUMPRODUCT((YEAR(A2:A100)=F2)*(A2:A100>=DATE(F2,7,1))*(A2:A100<=DATE(F2+1,6,30)))

Python (pandas with a custom fiscal calendar)

import pandas as pd

df = pd.DataFrame({
    'date': pd.date_range('2023-01-01','2025-12-31', freq='D')
})

# Fiscal year starts July 1
df['fiscal_year'] = df['date'].dt.year + (df['date'].dt.month >= 7)

# Filter for a specific fiscal year and count days
fy = 2024
days_in_fy = df[df['fiscal_year'] == fy].shape[0]
print(days_in_fy)   # 366 for a leap year fiscal period

---

5. Astronomical Time

Astronomical Time

When a calculation hinges on the Sun’s position rather than a civil calendar, ordinary “days” give way to solar, sidereal, or Julian Day measurements. The following sections show how to convert a calendar date to those astronomical counters and then back again.

Julian Day Number (JDN) – Excel

The classic formula for the Julian Day Number of a Gregorian calendar date is:

=INT( (1461 * (Y + 4800 + INT((M-14)/12)) ) / 4 )
+ INT( (367 * (M - 2 - 12INT((M-14)/12)) ) / 12 )
- INT( (3 * INT( (Y + 4900 + INT((M-14)/12))/100 ) ) / 4 )
+ D - 32075

For dates after 1582‑10‑15 (the start of the Gregorian calendar) the formula above is accurate. Earlier dates require the Julian calendar variant.

Julian Date (JD) – Python (using Astropy)

The astropy.time module makes the conversion straightforward:

from astropy.time import Time

# A specific UTC moment
t = Time('2024-06-21T00:00:00', format='isot', scale='utc')
print(t.jd)          # Julian Date (days, including fractional part)
print(t.jd1, t.jd2)  # Two‑part JD for high‑precision work

If you need the Modified Julian Day (MJD = JD − 2400000.Now, 5) just subtract 2. 4e6.

Sidereal Time – R (using astrochron)

The Greenwich Mean Sidereal Time (GMST) in hours can be obtained with:

library(astrochron)
gmst <- gmst('2024-03-20 12:00:00', tz = 'UTC')
# Returns a decimal hour value (0–24)

For a specific longitude, add the longitude (in hours) to the GMST to obtain the Local Sidereal Time (LST).

Counting days between astronomical events

Because JD is a continuous count, the difference is simply:

=JD2 - JD1

or in Python:

delta_days = t2.jd - t1.jd

No DST or leap‑second worries apply to the astronomical timeline.

Tip: When you need the exact moment of sunrise, equinox, or moon phase, use a dedicated astronomy library rather than manual formulas; the corrections for nutation, precession, and leap seconds are non‑trivial.

---

Conclusion

Counting days across calendars, time‑zones, and astronomical systems is rarely a one‑size‑fits‑all problem. The key steps are:

1. Clarify the calendar – Gregorian, Julian, business‑day, or fiscal period.
2. Anchor timestamps – Store them in a zone‑aware format (UTC or explicit offset) and convert to local time only for presentation.
3. Apply the right tool – Built‑in functions for simple gaps, NETWORKDAYS/WORKDAY for business schedules, period masks for fiscal periods, and astronomy libraries for celestial events.
4. Validate with edge cases – Leap years, DST transitions, and cross‑zone boundaries expose hidden bugs.

By systematically addressing these variables, you can move from a fragile “midnight‑to‑midnight” count to a solid, reproducible method that works for global teams, financial reporting, and scientific calculations alike.