--- title: '5 Airtable Date Formulas You Should Know' description: 'Master the 5 Airtable date formulas that solve 90% of real business problems — DATEADD, DATETIME_DIFF, WORKDAY, TODAY, and IS_AFTER with copy-paste examples.' canonical_url: 'https://www.business-automated.com/tutorials/airtable-date-formulas' md_url: 'https://www.business-automated.com/tutorials/airtable-date-formulas.md' last_updated: 2026-04-05 --- Airtable date formulas are the difference between a static database and a living [business system](/airtable-consultant). They drive SLA dashboards, renewal reminders, project timelines, and every "is this overdue?" flag you've ever built in [Airtable](/airtable-consultant). The platform ships with more than twenty date functions, but five of them carry most of the weight in real projects. This guide covers those five — with exact syntax, gotchas, and examples pulled from client bases we've built. If you want the full function reference, start with our [complete Airtable formulas cheat sheet](/tutorials/airtable-formulas-cheat-sheet). The goal here is focused depth, not breadth. ## 1. DATEADD — Calculate Dates Relative to Another Date DATEADD is the formula you reach for whenever a date depends on another date. SLA due dates, renewal reminders, follow-up queues, payment terms — anything of the form "X days/weeks/months after (or before) Y." **Syntax:** ```airtable-formula DATEADD(date, count, 'units') IF({Status} = "Active", "https://example.com/profile", "No URL") CONCATENATE("https://api.example.com/v1/", {Record ID}) ``` - `date` — any date field or date expression (including `TODAY()` and `NOW()`) - `count` — a positive or negative integer - `'units'` — one of `'seconds'`, `'minutes'`, `'hours'`, `'days'`, `'weeks'`, `'months'`, `'years'` **Copy-paste examples:** ```airtable-formula // 48-hour SLA from a ticket's creation time DATEADD({Created At}, 48, 'hours') // One-week-early reminder before a contract renewal DATEADD({Renewal Date}, -7, 'days') // Net-30 invoice due date DATEADD({Invoice Date}, 30, 'days') // Quarterly review date DATEADD({Hire Date}, 3, 'months') ``` The negative-count trick is what makes DATEADD so useful for reminders. If you want an automation to fire a week before a deadline, you don't build a separate "reminder date" field and hand-enter it — you compute it from the deadline itself, so it stays in sync when the deadline moves. **Common DATEADD gotcha: month math**\ `DATEADD('2026-01-31', 1, 'months')` does **not** return February 31 (which doesn't exist). Airtable rounds forward sensibly, but the result depends on the calendar. When month-based math really matters (billing cycles, for example), always spot-check the edge dates with a view filter rather than trusting the formula blindly. ## 2. DATETIME_DIFF — Measure the Distance Between Two Dates DATETIME_DIFF is how you answer "how long?" — how long a ticket has been open, how many days a project took, how old a lead is, how many hours between a meeting and a deliverable. **Syntax:** ```airtable-formula DATETIME_DIFF(date1, date2, 'unit') ``` The function returns `date1 - date2` in the unit you ask for. If `date1` is earlier than `date2`, the result is negative, which is useful for "days until" vs. "days since" logic. **Valid units:** `'milliseconds'`, `'seconds'`, `'minutes'`, `'hours'`, `'days'`, `'weeks'`, `'months'`, `'quarters'`, `'years'`. See the official [Airtable DATETIME_DIFF unit specifiers reference](https://support.airtable.com/hc/en-us/articles/226061308-Supported-unit-specifiers-for-DATETIME-DIFF) for the full list. **Copy-paste examples:** ```airtable-formula // Age of an open ticket, in days DATETIME_DIFF(NOW(), {Created At}, 'days') // Days until a project deadline (negative = overdue) DATETIME_DIFF({Due Date}, TODAY(), 'days') // Project duration in weeks DATETIME_DIFF({End Date}, {Start Date}, 'weeks') // Hours between a meeting and the deliverable DATETIME_DIFF({Due At}, {Meeting At}, 'hours') ``` **The inclusive-range trick**\ `DATETIME_DIFF({End}, {Start}, 'days')` returns **exclusive** days — if start and end are the same day, you get 0. For "inclusive" ranges (useful for things like hotel stays or multi-day events), add one day to the end: ```airtable-formula DATETIME_DIFF(DATEADD({End Date}, 1, 'days'), {Start Date}, 'days') ``` This combination of DATEADD and DATETIME_DIFF is one of the most common patterns in production bases, so it's worth committing to memory. ## 3. WORKDAY — Skip Weekends Automatically Most businesses don't care about weekends. When a ticket lands Friday at 5pm and the SLA is "two business days," you don't want the due date to be Sunday — you want Tuesday. That's what WORKDAY is for. **Syntax:** ```airtable-formula WORKDAY(startDate, numDays, [holidays]) ``` - `startDate` — the date to count from - `numDays` — the number of business days to add (Saturday and Sunday are excluded automatically) - `[holidays]` — optional comma-separated string of dates to also skip **Copy-paste examples:** ```airtable-formula // 2-business-day SLA WORKDAY({Submitted At}, 2) // 5-business-day turnaround, skipping two company holidays WORKDAY({Brief Received}, 5, '2026-12-25, 2026-12-26') // 30-business-day delivery window WORKDAY({Order Date}, 30) ``` **WORKDAY vs. DATEADD**\ If someone is paying you for a service-level agreement, use WORKDAY. If you're calculating things like contract expirations, trial end dates, or subscription renewals that absolutely tick calendar-forward, use DATEADD. Mixing them up is how you end up explaining to a client why their "5 business day" SLA silently included Saturdays. There's also `WORKDAY_DIFF` — the inverse function that counts business days between two existing dates. It's perfect for calculating how long a ticket was actually open in business time, or measuring real delivery cycles without weekend distortion. ## 4. TODAY — The Date That Moves With You TODAY() returns the current date (no time component). It's the anchor for every rolling, real-time calculation in your base: "days until my deadline," "is this overdue right now," "how old is this record today." **Syntax:** ```airtable-formula TODAY() ``` That's it. No arguments. **Copy-paste examples:** ```airtable-formula // Days remaining until a deadline DATETIME_DIFF({Due Date}, TODAY(), 'days') // Overdue flag IF(IS_BEFORE({Due Date}, TODAY()), '🔴 Overdue', '🟢 On Track') // Records created more than 90 days ago IF(DATETIME_DIFF(TODAY(), {Created Date}, 'days') > 90, 'Stale', 'Fresh') ``` ### Two things to know about TODAY() **It runs in UTC.** TODAY() evaluates using Airtable's server clock, not your laptop's clock. If your business is in Sydney and your SLA is "respond today," you'll get a nasty surprise around 10am local time when UTC finally rolls over. Wrap date fields in `SET_TIMEZONE({Field}, 'Australia/Sydney')` before comparing, or use `DATETIME_FORMAT(..., 'YYYY-MM-DD')` to compare as strings anchored to your locale. **It doesn't recalculate instantly.** Airtable refreshes formulas that depend on TODAY() on a rolling schedule — usually within a few minutes of a new day, but not to the second. If you need millisecond accuracy, use NOW() instead. For day-level calculations (which is what most people want), TODAY() is the right tool. ## 5. IS_AFTER (and IS_BEFORE, IS_SAME) — The Date Comparators Plain comparison operators work on dates in Airtable, but they're finicky around blank values and time precision. The `IS_AFTER`, `IS_BEFORE`, and `IS_SAME` functions are cleaner, safer, and more readable. **Syntax:** ```airtable-formula IS_AFTER(date1, date2) IS_BEFORE(date1, date2) IS_SAME(date1, date2, 'unit') ``` All three return `1` (true) or `0` (false). `IS_SAME` takes an optional unit so you can ask "are these the same day?" without worrying about hours and minutes. **Copy-paste examples:** ```airtable-formula // Overdue status IF(IS_BEFORE({Due Date}, TODAY()), 'Overdue', 'On Track') // Future-dated tasks only IF(IS_AFTER({Start Date}, TODAY()), 'Scheduled', 'Active or Past') // Same-day meetings IF(IS_SAME({Meeting Time}, TODAY(), 'day'), '📍 Today', DATETIME_FORMAT({Meeting Time}, 'MMM D')) // Still within the free trial window IF(IS_BEFORE(TODAY(), DATEADD({Signup Date}, 14, 'days')), 'In Trial', 'Paid or Expired') ``` The last example is a pattern you'll use constantly: combine IS_BEFORE with DATEADD and TODAY to create "is this record still inside a rolling window?" checks. Trials, warranty periods, grace periods, retention windows — all the same shape. ## Putting It Together: A Real SLA Formula Here's a formula we've deployed in real client bases — a multi-tier SLA status that combines four of the five functions in this guide: ```airtable-formula IF( {Resolved At}, '✅ Closed', IF( IS_AFTER( NOW(), WORKDAY({Created At}, IF({Priority} = 'P1', 1, IF({Priority} = 'P2', 3, 5))) ), '🔴 SLA Breached', IF( DATETIME_DIFF( WORKDAY({Created At}, IF({Priority} = 'P1', 1, IF({Priority} = 'P2', 3, 5))), NOW(), 'hours' ) <= 4, '🟡 At Risk', '🟢 On Track' ) ) ) ``` It reads like a lot, but every piece is one of the five formulas we covered: 1. **WORKDAY** computes the SLA target from the ticket create date, skipping weekends. 2. **IS_AFTER** checks whether "now" is past that target (breached). 3. **DATETIME_DIFF** measures how close we are to the deadline in business hours. 4. **IF** branches on priority and on status to return the right label. This is the level of logic that makes formulas feel like superpowers — and why it's worth learning the date functions cold before you reach for an automation. ## When Formulas Aren't Enough Sometimes you need date logic that touches multiple records, runs on a schedule, or sends a notification. That's where Airtable automations and scripting come in. See our guide on [automating Airtable with Make](/airtable-consultant) for the next layer up the stack, or [the complete Airtable automation guide](/tutorials/airtable-automation-guide) for the pillar piece. If you're wrangling deeply nested IFs in your date formulas, also take a look at [SWITCH to escape IF hell](/tutorials/airtable-switch-vs-nested-if) — it often makes priority-based date logic much cleaner. ## Get It Right the First Time Broken date logic is one of the most common things we fix during Airtable rescue engagements. Off-by-one errors, UTC surprises, weekends counted when they shouldn't be, overdue flags that never flip. The five functions in this guide are enough to prevent most of them — once you know the gotchas. Need help auditing a base that's making bad time decisions, or designing an SLA system that holds up in production? [Business Automated](/airtable-consultant) ships Airtable implementations for agencies, operators, and professional services teams every week. We've seen every date bug there is, and we'd rather you didn't have to. ## Sitemap See the full [sitemap](/sitemap.md) for all pages.