Notion Formulas 2.0: What Changed and How to Fix Old Formulas

Formulas 2.0 is the formula language Notion runs today. It rolled out in September 2023, appears in Notion's release notes for Notion 2.33 on 22 September 2023, and existing formulas were converted automatically. If you're learning from scratch, start with tokens, dot notation and lists. If a formula copied from an old template fails, I'd rewrite it pattern by pattern, because each fix below maps to a documented change.

Three changes cause most of the confusion when an older formula meets the current editor. The editor shows properties as tokens instead of prop("Name"). Multi-select, person and relation properties arrive in a formula as lists, which is why Notion wrapped older person formulas in a text conversion. And a formula can now return pages, dates, people and lists, where it used to stop at text, numbers and checkboxes.

Start from what you're trying to do

What changed when formulas moved to 2.0

Notion's Formulas 2.0 guide names three aims: formulas are easier to write, outputs include more property types, and the language can fulfill more specific needs. In a formula you open today, that shows up as eight changes.

Properties appear as tokens

In the editor, a property shows as a token rather than a prop() call. Ben Borowski's walkthrough of everything new in Formulas 2.0 on Notion Mastery shows length(prop("My Text")) displayed as length(My Text), and notes that a prop reference you type turns into a token straight away. Copying a formula out still gives you prop("Name"), so formulas shared in posts, like the examples in Notion's syntax reference, use prop().

The editor takes lines, comments and error hints

Formulas can run over several lines, with tabs and comments, and the editor type-checks your formula and highlights errors right in the editor. Comments sit between /* and */, and Notion Mastery adds a new line with Cmd/Ctrl + Enter. Notion's intro to formulas describes the rest: the field at the top tells you what's missing or what the formula expects, the left panel lists the properties, built-ins and functions you can use, and the right panel explains each element with examples as you hover. Open the editor from a database row and you get a live preview of that row's result.

Dot notation chains functions

A function can follow its first input after a dot. Notion Mastery shows that dateAdd(Date, 1, "years") and Date.dateAdd(1, "years") call the same function with the same arguments, so nested calls become a chain you read left to right. The capitalize-the-first-letter recipe writes one text formula both ways if you want to compare the two styles on something other than dates.

Multi-select, person and relation properties are lists

Notion's formula syntax reference maps each property to a formula type: Multi-select becomes Text (list), Person becomes Person (list), and Relation becomes Page (list). Lists come with functions such as map(), filter(), find() and every(). Inside them, current is the item being processed and index is its position, counted from zero. People carry account details too, so prop("Created By").name() and prop("Created By").email() return a name and an email without a separate property.

Related pages work without a rollup

A formula can reach into a related database directly. Notion's example counts the finished tasks on a project:

prop("Tasks").map(current.prop("Status")).filter(current == "Done").length()

Before 2.0, you'd have built a rollup to show task completion and then pointed a formula at it.

Outputs go beyond text, numbers and checkboxes

Formulas used to support text, number and checkbox outputs. They now display pages, dates, people and lists as well. Text output can carry formatting through style(): bold, underline, italics, code, strikethrough and nine colors, each with a background version, as in style("Notion", "blue", "gray_background"). unstyle() strips it again.

let() and lets() name a value once

let() stores a value under a name and uses it in the rest of the formula. Notion's example works out sales tax once and reuses it:

let(SalesTax, (prop("Subtotal")*0.099), prop("Subtotal") + SalesTax)

lets() takes several name and value pairs before the final expression.

ifs() replaces nested if()

ifs() takes condition and result pairs and returns the result of the first true condition. Notion's reference calls it an alternative to multiple nested if() statements, and a final argument without a condition acts as the default.

Fix a formula you copied from an old template

Formulas already in your workspace were converted when 2.0 arrived, so they kept their results. Formulas copied from older posts and templates are a different case. Matthias Frank's Formulas 2.0 tutorial says the new language isn't backwards compatible and that you can no longer paste old formulas into the new editor. Work through the formula one pattern at a time:

1. Write down the expected result for one real row. Then open the editor from that row, so the live preview shows what the formula returns now.
2. Remove the text conversion when you want real people or lists. To keep outputs unchanged, Notion converted formulas that referenced rollup, person, file and multi-select properties to text, so a person formula became prop("Person").map(current.format()).join(", "). Use prop("Person") on its own to get a list of people. Leave the conversion in place if a line of names is what you need.
3. Read related pages directly. If a rollup exists only to feed the formula, use map() and filter() on the relation, as in the finished-tasks example above.
4. Flatten nested if() into ifs(). The rewrite is shown below.
5. Chain nested date functions. Dot notation removes the inside-out reading and the risk of a missing parenthesis.
6. Name any value you repeat with let(). One name, one calculation, fewer places to make a typo.
7. Check that every branch returns the same type. The type rule is explained after the rewrites.
8. Read the highlighted error before you change more. The field at the top of the editor tells you what's missing or what it expects.

A nested if() rewritten with ifs()

Notion Mastery's size example starts with three nested calls:

if(Count >= 10, "Large", if(Count >= 5, "Medium", if(Count > 0, "Small", "None")))

With ifs(), each condition sits next to its result, and the comments label the branches:

ifs(
  /* LARGE */ Count >= 10, "Large",
  /* MEDIUM */ Count >= 5, "Medium",
  /* SMALL */ Count > 0, "Small",
  /* DEFAULT */ "None"
)

Nested dates rewritten as a chain

From the same walkthrough, this 1.0 version adds a year and then two days:

dateAdd(dateAdd(prop("Date"), 1, "years"), 2, "days")

Written as a 2.0 chain, it reads in the order the steps happen. Date here is the property token; copied out of the editor it reads prop("Date").

Date
  .dateAdd(1, "years")
  .dateAdd(2, "days")

If a date formula fails because its input turns out to be text or a list, the guide to Notion formula date errors works through each input type.

Why a number turned into text

In 1.0, if(now() > prop("Birthday"), 1, "A") raised a type mismatch because 1 and "A" are different types. Notion Mastery notes that 2.0 accepts it but coerces the result to text, so number formatting no longer applies to the 1. Thomas Frank's Notion formula cheat sheet states the rule behind it: a formula can only return data of a single type. If number formatting has disappeared from a formula column, look for a branch that returns text.

Where to find the Formulas 2.0 documentation

Notion spreads its formula documentation over three help pages, and each answers a different question:

• Notion's formula syntax and functions reference maps every property type to its formula type and lists each built-in and function with examples. Most entries show the exact result, which makes it the page to keep open while you write.
• For the 2.0 changes themselves, the what's-changed guide for Formulas 2.0 explains the automatic conversion, the new output types and the related-database example. Its toggles cover changes to property referencing, math, date, text and checkbox functions.
• Notion's intro to formulas covers where formulas run, how to create one, the editor panels and Notion AI.

Inside the editor, the right-hand panel gives a definition and examples for whatever you hover over. Once you know a function's name, I'd check there before the help center, because the definition sits next to the formula you're writing. For one long page with example code for every function, Thomas Frank's cheat sheet is the outside reference I'd bookmark.

Where you can use a formula

The same language runs in four places. Notion's intro lists them as a database property, a button action, a database button action and a database automation action. To add the property version, select the slider icon at the top of a database → Edit properties → New property, choose Formula, name it, and select Edit formula.

In a database automation, a formula can read the page that started the run. Notion's example marks a parent task Done once its sub-items are done, and its first step finds the parent with Trigger page.Parent item.first(). Trigger page is the page the automation was triggered from, and the dot reads its properties. The next step checks the sub-items with every() and returns false when there are none, so the formula decides the value. Which event should start the run, and what the automation should leave alone, stays your call.

If you're still choosing between a button someone clicks and an automation that fires on its own, the buttons vs automations comparison sets out the difference. To write that rule down before you build it, use the trigger, action and exception worksheet for automations.

Should Notion AI write the formula for you?

Notion AI can write and edit formulas from inside the formula editor, and Notion's formula help lists that feature for Business and Enterprise plans. You type into the field with the Notion AI face, either describing the result you want or asking about the formula already there, with prompts such as "What does this formula do?" or "Fix the errors in this formula." It previews the output, and Show types displays the output type. Notion lists three things it doesn't handle: iterative logic such as for loops, random values (formulas have no random() function), and remembering previous prompts. Formula writing was one of the features Notion promoted in its Notion 3.0 release.

I'd start by asking it to explain an inherited formula, because an explanation is easy to check against the code in front of you. When it writes a new formula, deciding whether the result is right stays with you: compare the preview against a row whose answer you already know. If AI is the reason you'd move to Business, the Notion AI review for small teams covers what Business adds to the per-member cost.

Check your reading against documented results

The quickest way to learn the 2.0 functions is to predict a result and compare it with a published one. Every result below is the exact output published with the formula, in Notion's syntax reference or Ben Borowski's Notion Mastery walkthrough. Cover the result column, write your answer, then check.

If the index row caught you out, the same zero-based counting applies elsewhere: at([1, 2, 3], 1) returns 2. The date row depends on when you run it, because now() returns the current date and time.

Start with one formula you already use

1. Pick one formula in a database you open every week, ideally one copied from somewhere else.
2. Open the formula editor from a row whose result you already know, so the live preview shows that row.
3. Find one pattern from the checklist: a text conversion, a rollup that only feeds the formula, a nested if(), a nested date function or a repeated value.
4. Rewrite that pattern only, and compare the preview with the result you wrote down.
5. Add a comment between /* and */ that says what the formula returns, so the next person who opens it can read it.

My verdict: Formulas 2.0 isn't something you migrate to; it's the language your workspace already runs. For a freelancer with a few inherited formulas, I'd touch them only when one fails or shows text where you need people or a list, because Notion's conversion kept their results. For a small team building client databases, I'd rewrite the formulas that sit on top of a rollup first, because reading the relation directly removes a property the formula no longer needs. If you're setting up that client and project structure from scratch, the relations and rollups build shows the database layout these formulas read from.

Questions that come up next

When was Formulas 2.0 released?

In September 2023. Notion Mastery published its walkthrough of the new language on 7 September 2023, and Notion's release notes list Formulas 2.0 under Notion 2.33 on 22 September 2023, in the same release as database automations and frozen columns in table view.

Did Formulas 2.0 change the Notion API?

Yes, for formula properties. Notion's developer changelog says the create and update database endpoints accept the old formula format as input indefinitely, alongside the new one, while database objects returned through the API carry the 2.0 format. An integration that reads formula expressions should expect the new format in responses.

Do I still need rollups?

Rollups still exist, and formulas can read them: the syntax reference lists a rollup as returning a number, a date or a list, depending on how it's configured. I'd keep a rollup that people read on its own and replace one that exists only to feed a formula, because the formula can now do both steps.