> ## Documentation Index
> Fetch the complete documentation index at: https://docs.allgoodhq.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Formula reference: functions and operators

> Look up every MK formula operator, function, and blank-value check, with a before and after example and how each behaves on empty fields.

Use this page to look up a function, an operator, or how a formula treats a blank field. Each entry shows what you type, what it does, and a before and after example. New to formulas? Start with [What formulas are and when to use one](https://docs.allgoodhq.com/mk/formulas/what-formulas-are.md).

A formula reads fields from one record and gives back one answer. In a list filter, the answer must be true or false. In a list column, the answer is what each row shows. Formulas never change your data.

In every table on this page, the quotes around text show exactly where it starts and ends, so you can see spaces. The quotes are not part of the value. Rows marked "same formula" use the formula from the row above.

## Terms used on this page

| Term | What it means |
| - | - |
| Record | One person or one company in MK. Each row in a list is a record. |
| Record type | A kind of data a record carries. A person can have several at once, such as the standard `person` record and a record that came from a connected system. A formula names the record type every time it reads a field. |
| Field | One piece of data on a record type, such as `title` on `person`. |
| Read | Fetching a field's value into the formula, written `` $`record.field` ``. |
| Value | Whatever a read, a piece of typed text, a number, or a calculation gives back. |
| No value | A field with nothing stored in it. This also covers a field, or a whole record type, that the record does not have. Formulas write it as `null`. |
| Empty text | Text with no characters in it, written `''`. A form field a visitor left empty often arrives this way. |
| Spaces-only text | Text that contains only spaces, such as `'  '`. |
| Blank | No value, empty text, or spaces-only text. This is exactly what `empty()` treats as nothing. The number `0` and the word `false` are not blank. |
| Filled | Not blank. |
| Counts as true / counts as false | How a formula reads a value that is not already true or false, in places that need a yes or no. It applies after `!`, around `&&` and `\|\|`, and before `?` in a choice. These values count as false: no value, empty text, `0`, and `false`. Every other value counts as true. That includes spaces-only text, `'0'`, `'false'`, `'no'`, and an empty list. |
| Condition | Anything that gives back true or false, such as a comparison or `empty()`. |
| Operator | A symbol that works on values, such as `==`, `&&`, or `+`. |
| Function and method | A named action. A function stands alone, such as `empty(…)`. A method follows a value after a dot, such as `.toLowerCase()`. |
| Fixed text | Text you type into the formula inside single quotes, such as `'Acme'`. |

## What counts as blank

Four checks ask "is there anything here?" in four different ways. They disagree on spaces-only text, `0`, and `false`, so the check you pick matters.

| Value stored in the field | `empty()` is | `exists()` is | Counts as true | `flag()` is | `=== null` is |
| - | - | - | - | - | - |
| No value | true | false | no | false | true |
| Empty text `''` | true | false | no | false | false |
| Spaces-only text `'  '` | true | false | yes | false | false |
| Text `'a'` | false | true | yes | false | false |
| The number `0` | false | true | no | false | false |
| `false` | false | true | no | false | false |
| Text `'0'` | false | true | yes | false | false |
| Text `'false'` | false | true | yes | false | false |
| An empty list `[]` | false | true | yes | false | false |
| The number `5` | false | true | yes | false | false |

How to choose:

* Use `empty()` and `exists()` to ask whether a field has anything real in it. They treat spaces-only text as nothing, and `0` as something.
* Use `flag()` to ask whether a field says yes. See [Check for blank values](#check-for-blank-values) below.
* Use `=== null` only to ask whether the field has no value at all. Empty text does not match.
* Let a value count as true or false only when you want `0` and `false` treated as nothing, or when you are sure the field never holds spaces-only text.

## Read a field

| What you type | What it does | Example |
| - | - | - |
| `` $`record.field` `` | Reads a field. Start with the record type, then the field name. | `` $`person.title` `` |
| `$('record', 'field')` | Does the same thing. Use it only when a field name contains a period. | `$('lead', 'region.code')` |

Field names must match exactly, including capitalization. A misspelled name reads as no value, and MK does not show an error. Always include the record type. A bare `` $`email` `` looks for a record type called "email" and finds nothing.

## Values you can type

| Kind | Example |
| - | - |
| Text | `'Acme'` |
| Number | `42` or `-1.5` |
| True or false | `true` or `false` |
| No value | `null` |
| List of values | `['ceo', 'cfo']` |

Text and numbers mix in a few ways:

* `==` treats a field holding the text `5` as equal to the number `5`.
* Math works on a field whose text looks like a number. If `lead.score` holds the text `5`, then ``$`lead.score` + 1`` gives `6`.
* Math on a field whose text is not a number fails with an error. If `person.firstName` holds `Ann`, then ``$`person.firstName` + 1`` is rejected.

## Compare values

| What you type | What it does | Example |
| - | - | - |
| `==` | True when both sides are equal. | ``$`person.lifecycleStage` == 'customer'`` |
| `!=` | True when the sides are different. | ``$`person.consent` != 'unsubscribed'`` |
| `<` `<=` `>` `>=` | Compares numbers or text. | ``$`company.employeeCount` >= 500`` |

`===` and `!==` work the same as `==` and `!=`. Text comparisons are case-sensitive, so `'VP'` does not equal `'vp'`. To ignore case, convert the field first, as in ``$`person.title`.toLowerCase() == 'vp'``.

A field with no value only equals another no value. So ``$`person.title` == ''`` is false when the title has no value. Use `empty($`person.title`)` to catch both.

**Before and after**

| Formula | Before | After |
| - | - | - |
| ``$`person.lifecycleStage` == 'customer'`` | `'customer'` | `true` |
| same formula | `'Customer'` (capital C) | `false` |
| same formula | `'lead'` | `false` |
| ``$`person.consent` != 'unsubscribed'`` | `'subscribed'` | `true` |
| same formula | `'unsubscribed'` | `false` |
| ``$`company.employeeCount` >= 500`` | `1200` | `true` |
| same formula | `80` | `false` |
| same formula | no value | `false` |
| ``$`person.title`.toLowerCase() == 'vp'`` | `'VP'` | `true` |

> [!NOTE]
>
> In `<` and `>` comparisons, no value counts as 0. That makes ``$`company.employeeCount` < 500`` true for a company with no employee count, and ``$`company.employeeCount` > 500`` false. To leave those records out, check first: ``exists($`company.employeeCount`) && $`company.employeeCount` < 500``.

## Combine conditions

| What you type | What it does | Example |
| - | - | - |
| `&&` | "And." True when both sides are true. | ``$`person.title`.includes('VP') && exists($`person.email`)`` |
| `\|\|` | "Or." True when either side is true. | ``empty($`person.phone`) \|\| empty($`person.email`)`` |
| `!` | "Not." Flips true to false, and false to true. | ``!$`person.title`.includes('Intern')`` |
| `??` | Returns the first value that is not "no value." | `` $`person.fullName` ?? $`person.firstName` `` |

`&&` and `||` do not always give back true or false. They give back one of the two sides, chosen by whether it counts as true. `'a' && 'b'` gives `'b'`. `'' || 'b'` gives `'b'`. In a filter, make both sides conditions, such as comparisons or `empty()`, so the answer is always true or false.

`||` and `??` differ in what they skip:

* `||` skips anything that counts as false: no value, empty text, `0`, and `false`. It does not skip spaces-only text.
* `??` skips only no value. It keeps empty text, spaces-only text, and `0`.

Use `??` when `0` is a real answer. Use `||` when empty text should fall through. Neither one treats spaces-only text as nothing. To handle that, see [Handle blank and messy values in formulas](https://docs.allgoodhq.com/mk/formulas/handle-blank-values.md).

When you mix `&&` and `||` in one formula, add parentheses to show which goes first, as in ``(exists($`person.email`) || exists($`person.phone`)) && $`person.lifecycleStage` == 'lead'``.

**Before and after**

| Formula | Before | After |
| - | - | - |
| ``$`person.title`.includes('VP') && exists($`person.email`)`` | Title `'VP of Marketing'`, has an email | `true` |
| same formula | Title `'VP of Marketing'`, no email | `false` |
| ``empty($`person.phone`) \|\| empty($`person.email`)`` | Phone `''`, email `'a@b.co'` | `true` |
| same formula | Phone `'555'`, email `'a@b.co'` | `false` |
| ``!$`person.title`.includes('Intern')`` | `'Marketing Intern'` | `false` |
| same formula | `'Director'` | `true` |
| `` $`person.fullName` ?? $`person.firstName` `` | Full name: no value. First name: `'Jordan'` | `'Jordan'` |
| same formula | Full name: `'Jordan Rivera'`. First name: `'Jordan'` | `'Jordan Rivera'` |

## Do math and join text

| What you type | What it does | Example |
| - | - | - |
| `+` | Adds numbers, or joins text when one side of the `+` is text you typed. | `` $`person.firstName` + ' ' + $`person.lastName` `` |
| `-` `*` `/` | Subtracts, multiplies, divides. | ``$`company.annualRevenue` / 12`` |

**Before and after**

| Formula | Before | After |
| - | - | - |
| ``$`company.annualRevenue` / 12`` | `1200000` | `100000` |
| ``$`company.annualRevenue` - 50000`` | `1200000` | `1150000` |
| `` $`person.firstName` + ' ' + $`person.lastName` `` | First name `'Jordan'`, last name `'Rivera'` | `'Jordan Rivera'` |

Three rules to know before you use `+` and math:

* To join two fields, include some typed text between them, even if it is only a space. `` $`person.firstName` + $`person.lastName` `` tries to add the two fields as numbers and fails with an error. `` $`person.firstName` + ' ' + $`person.lastName` `` joins them.
* When joining, a field with no value turns the whole result into no value. Empty text is fine. [Handle blank and messy values in formulas](https://docs.allgoodhq.com/mk/formulas/handle-blank-values.md) shows the fix.
* In math, no value counts as 0. ``$`company.annualRevenue` / 12`` gives `0` for a company with no revenue. It does not give no value. [Handle blank and messy values in formulas](https://docs.allgoodhq.com/mk/formulas/handle-blank-values.md) shows how to leave those rows empty.

## Choose a value

| What you type | What it does | Example |
| - | - | - |
| `condition ? a : b` | Returns `a` when the condition is true, otherwise `b`. | ``$`company.employeeCount` >= 1000 ? 'Enterprise' : 'Mid-market'`` |

You can chain choices to sort records into more than two groups. MK checks them from left to right and stops at the first condition that is true:

```
$`company.employeeCount` >= 1000 ? 'Large' : $`company.employeeCount` >= 100 ? 'Medium' : 'Small'
```

**Before and after**

| Formula | Before (employee count) | After |
| - | - | - |
| The three-group formula above | `1200` | `'Large'` |
| same formula | `250` | `'Medium'` |
| same formula | `40` | `'Small'` |
| ``$`company.employeeCount` >= 1000 ? 'Enterprise' : 'Mid-market'`` | `250` | `'Mid-market'` |

## Check for blank values

| What you type | What it does | Example |
| - | - | - |
| `empty(a, b, …)` | True when every field listed is blank. | ``empty($`person.phone`)`` |
| `exists(a, b, …)` | True when every field listed is filled. | ``exists($`person.email`, $`person.firstName`)`` |
| `x === null` | True only when `x` has no value. Never gives back no value itself. | ``$`company.annualRevenue` === null`` |
| `flag(a)` | Reads a field as yes or no. | ``flag($`lead.opted_in`)`` |

`empty()` and `exists()` always give back true or false. They never give back no value, and they never fail on a field that has nothing in it.

`flag()` is for fields that spell out a yes or no in words, instead of holding a true or false value. It returns true for these values, in any capitalization: `true`, `t`, `yes`, `y`, `on`, and `1`. It also returns true for the number `1`. Everything else is false. That includes no value, empty text, `0`, `2`, `no`, `maybe`, and any word `flag()` does not recognize. Spaces are not removed, so `' yes '` is false.

Without `flag()`, the text `'no'` and the text `'false'` both count as true, because they are not empty. Use `flag()` whenever a field holds words like these.

**Before and after**

| Formula | Before | After |
| - | - | - |
| ``empty($`person.phone`)`` | `'  '` (spaces only) | `true` |
| same formula | `'+1 415 555 2671'` | `false` |
| ``exists($`person.email`, $`person.firstName`)`` | Email `'a@b.co'`, first name `'Jordan'` | `true` |
| same formula | Email `'a@b.co'`, first name `''` | `false` |
| ``$`company.annualRevenue` === null`` | No value | `true` |
| same formula | `0` | `false` |
| ``flag($`lead.opted_in`)`` | `'Yes'` | `true` |
| same formula | `'TRUE'` | `true` |
| same formula | `'y'` | `true` |
| same formula | `'1'` | `true` |
| same formula | `'no'` | `false` |
| same formula | `' yes '` (spaces around it) | `false` |
| same formula | `''` | `false` |

## Chain values together

Checks combine. You can test several fields at once with `empty(a, b)` and `exists(a, b)`, pick the first filled value, and guard a field before you use it. [Handle blank and messy values in formulas](https://docs.allgoodhq.com/mk/formulas/handle-blank-values.md) walks through each pattern with before and after tables.

## Common patterns

| Goal | Formula |
| - | - |
| Records with no email at all | ``empty($`person.email`)`` |
| Records with both an email and a phone | ``exists($`person.email`, $`person.phone`)`` |
| Records with an email or a phone | ``!empty($`person.email`, $`person.phone`)`` |
| Records missing a first name or a last name | ``!exists($`person.firstName`, $`person.lastName`)`` |
| Display name that never shows "null" | ``$`person.fullName`.trim() \|\| 'friend'`` |
| A yes or no field, safely | ``flag($`lead.opted_in`) ? 'Opted in' : 'Not opted in'`` |
| Email domain match, ignoring case, skipping empties | ``exists($`person.email`) && $`person.email`.toLowerCase().endsWith('@gmail.com')`` |
| Show a value only when there is one | ``empty($`person.title`) ? null : $`person.title`.toUpperCase()`` |
| Pull the domain out of an email (`'jordan@acme.com'` becomes `'acme.com'`) | ``$`person.email`.split('@')[1]`` |
| Strip dashes and spaces from a phone number (`'415 555-2671'` becomes `'4155552671'`) | ``$`person.phone`.replaceAll('-', '').replaceAll(' ', '')`` |
| Get a first name from a full name (`'Jordan Rivera'` becomes `'Jordan'`) | ``$`person.fullName`.split(' ')[0]`` |

## Work with text

Text functions go after a field or a piece of text, like ``$`person.email`.toLowerCase()``. If the field has no value, the result is no value. That includes `.length`. A field with empty text has a length of `0`.

| What you type | What it does | Example |
| - | - | - |
| `.startsWith(text)` | True when the text begins with `text`. | ``$`person.email`.startsWith('info@')`` |
| `.endsWith(text)` | True when the text ends with `text`. | ``$`person.email`.endsWith('@acme.com')`` |
| `.includes(text)` | True when `text` appears anywhere inside. | ``$`person.title`.includes('Manager')`` |
| `.indexOf(text)` | Position where `text` first appears, counting from 0. Returns -1 when it does not appear. | ``$`person.email`.indexOf('@')`` |
| `.toLowerCase()` `.toUpperCase()` | Changes capitalization. | ``$`person.email`.toLowerCase()`` |
| `.trim()` `.trimStart()` `.trimEnd()` | Removes spaces from both ends, the start, or the end. | ``$`person.fullName`.trim()`` |
| `.replace(find, with)` | Replaces the first match. | ``$`person.phone`.replace('+1', '')`` |
| `.replaceAll(find, with)` | Replaces every match. | ``$`person.phone`.replaceAll('-', '')`` |
| `.padStart(length, text)` `.padEnd(length, text)` | Adds `text` to the start or end until the result reaches `length`. | ``$`lead.code`.padStart(8, '0')`` |
| `.repeat(count)` | Repeats the text. | `'-'.repeat(3)` |
| `.length` | Number of characters. | ``$`person.firstName`.length`` |
| `.charAt(n)` `.at(n)` | The character at position `n`, counting from 0. | ``$`person.firstName`.charAt(0)`` |
| `.substring(start, end)` `.slice(start, end)` | A piece of the text. | ``$`person.phone`.slice(0, 5)`` |
| `.split(separator)` | Breaks text into a list at each separator. Add `[0]`, `[1]`, and so on to pick one piece. | ``$`person.fullName`.split(' ')[0]`` |

**Before and after**

| Formula | Before | After |
| - | - | - |
| ``$`person.email`.toLowerCase()`` | `'Firstname.Lastname@MyCompany.ai'` | `'firstname.lastname@mycompany.ai'` |
| ``$`person.email`.toUpperCase()`` | `'Firstname.Lastname@MyCompany.ai'` | `'FIRSTNAME.LASTNAME@MYCOMPANY.AI'` |
| ``$`person.title`.toUpperCase()`` | `'vp of marketing'` | `'VP OF MARKETING'` |
| ``$`person.fullName`.trim()`` | `'  Jordan Rivera '` | `'Jordan Rivera'` |
| ``$`person.fullName`.trimStart()`` | `'  Jordan Rivera '` | `'Jordan Rivera '` |
| ``$`person.fullName`.trimEnd()`` | `'  Jordan Rivera '` | `'  Jordan Rivera'` |
| ``$`person.phone`.replace('-', '')`` | `'415-555-2671'` | `'415555-2671'` (first dash only) |
| ``$`person.phone`.replaceAll('-', '')`` | `'415-555-2671'` | `'4155552671'` |
| ``$`person.phone`.replace('+1 ', '')`` | `'+1 415 555 2671'` | `'415 555 2671'` |
| ``$`person.phone`.replaceAll('-', '').replaceAll(' ', '')`` | `'415 555-2671'` | `'4155552671'` |
| ``$`lead.code`.padStart(8, '0')`` | `'42'` | `'00000042'` |
| ``$`lead.code`.padEnd(5, '*')`` | `'42'` | `'42***'` |
| `'-'.repeat(3)` | No field needed | `'---'` |
| ``$`person.firstName`.length`` | `'Jordan'` | `6` |
| ``$`person.firstName`.charAt(0)`` | `'Jordan'` | `'J'` |
| ``$`person.firstName`.at(1)`` | `'Jordan'` | `'o'` |
| ``$`person.phone`.slice(0, 5)`` | `'+14155552671'` | `'+1415'` |
| ``$`person.phone`.substring(2, 5)`` | `'+14155552671'` | `'415'` |
| ``$`person.fullName`.split(' ')[0]`` | `'Jordan Rivera'` | `'Jordan'` |
| ``$`person.fullName`.split(' ')[1]`` | `'Jordan Rivera'` | `'Rivera'` |
| ``$`person.email`.split('@')[1]`` | `'jordan@acme.com'` | `'acme.com'` |
| ``$`person.email`.startsWith('info@')`` | `'info@acme.com'` | `true` |
| same formula | `'jordan@acme.com'` | `false` |
| ``$`person.email`.endsWith('@acme.com')`` | `'jordan@acme.com'` | `true` |
| ``$`person.title`.includes('Manager')`` | `'Senior Manager, Demand Gen'` | `true` |
| same formula | `'Director'` | `false` |
| ``$`person.email`.indexOf('@')`` | `'jordan@acme.com'` | `6` |
| same formula | `'jordan.acme.com'` | `-1` |
| ``exists($`person.email`) && $`person.email`.toLowerCase().endsWith('@gmail.com')`` | `'Jordan@GMAIL.com'` | `true` |

Some rules for `replace`, `replaceAll`, and `split`:

* The text you search for must be typed in, and it cannot be empty. It cannot come from a field.
* The replacement must be fixed text with no `$` in it. To use a field as the replacement, write it as `() => field`, for example ``$`lead.template`.replace('{{name}}', () => $`person.firstName`)``.
* Pattern matching (regular expressions) is not available.

## Work with lists of values

A list can be one you type, like `['ceo', 'cfo']`, or a field that holds several values, such as tags. In the functions that take `e => …`, `e` stands for each item in turn. You can name it anything, such as `tag => …`.

| What you type | What it does | Example |
| - | - | - |
| `.includes(value)` | True when the list contains `value`. | ``['ceo', 'cfo', 'coo'].includes($`person.title`.toLowerCase())`` |
| `.map(e => …)` | Changes every item. | ``$`lead.tags`.map(e => e.toLowerCase())`` |
| `.filter(e => …)` | Keeps the items where the condition is true. | ``$`lead.scores`.filter(e => e > 50)`` |
| `.some(e => …)` | True when at least one item matches. | ``$`lead.tags`.some(e => e == 'vip')`` |
| `.every(e => …)` | True when every item matches. | ``$`lead.scores`.every(e => e > 0)`` |
| `.reduce((total, e) => …, start)` | Folds the list into one value. The starting value is required. | ``$`lead.scores`.reduce((total, e) => total + e, 0)`` |
| `.join(separator)` | Joins items into text. With no separator, uses a comma. | ``$`lead.tags`.join(', ')`` |
| `.length` | Number of items. | ``$`lead.tags`.length`` |
| `.at(n)` `.slice(start, end)` | One item, or a section of the list. | ``$`lead.tags`.at(0)`` |
| `.toSorted()` `.toReversed()` | Sorts low to high, or reverses the order. | ``$`lead.scores`.toSorted()`` |
| `[...a, ...b]` | Combines lists. | ``[...$`lead.tags`, 'new']`` |

**Before and after**

| Formula | Before | After |
| - | - | - |
| ``['ceo', 'cfo', 'coo'].includes($`person.title`.toLowerCase())`` | Title `'CFO'` | `true` |
| same formula | Title `'Director'` | `false` |
| ``$`lead.tags`.map(e => e.toLowerCase())`` | `['VIP', 'Webinar']` | `['vip', 'webinar']` |
| ``$`lead.scores`.filter(e => e > 50)`` | `[20, 60, 90]` | `[60, 90]` |
| ``$`lead.tags`.some(e => e == 'vip')`` | `['lead', 'vip']` | `true` |
| same formula | `['lead']` | `false` |
| ``$`lead.scores`.every(e => e > 0)`` | `[20, 60, 90]` | `true` |
| same formula | `[20, 0, 90]` | `false` |
| ``$`lead.scores`.reduce((total, e) => total + e, 0)`` | `[20, 60, 90]` | `170` |
| ``$`lead.tags`.join(', ')`` | `['vip', 'webinar']` | `'vip, webinar'` |
| ``$`lead.tags`.join()`` | `['vip', 'webinar']` | `'vip,webinar'` |
| ``$`lead.tags`.length`` | `['vip', 'webinar']` | `2` |
| ``$`lead.tags`.at(0)`` | `['vip', 'webinar']` | `'vip'` |
| ``$`lead.tags`.slice(1)`` | `['vip', 'webinar', 'q4']` | `['webinar', 'q4']` |
| ``$`lead.scores`.toSorted()`` | `[10, 2, 1]` | `[1, 2, 10]` |
| ``$`lead.scores`.toReversed()`` | `[20, 60, 90]` | `[90, 60, 20]` |
| ``[...$`lead.tags`, 'new']`` | `['vip']` | `['vip', 'new']` |

Some behaviors to know:

* `.includes` on a typed list works as "is one of." It follows the same matching as `==`, so `['1'].includes(1)` is true.
* `.toSorted()` sorts numbers by value, so `[10, 2, 1]` becomes `[1, 2, 10]`. It always sorts low to high, and items with no value go last.
* A list function used on something that is not a list gives no value instead of an error.
* A function inside `e => …` can read fields, but cannot use the `e` of an outer function.

## Other forms

| What you type | What it does | Example |
| - | - | - |
| `({ name: value })` | Returns several named values at once. Wrap it in parentheses. Used in advanced setups. | ``({ name: $`person.fullName`, adult: true })`` |

**Before and after**

| Formula | Before | After |
| - | - | - |
| ``({ name: $`person.fullName`, adult: true })`` | `'Jordan Rivera'` | `{ name: 'Jordan Rivera', adult: true }` |

## What formulas can't do

MK checks a formula when you enter it. If it uses something outside what this page describes, MK rejects it and points to the spot, like this:

```
Formula: cannot use "%" operator (line 1, column 6)
```

These are not available:

* Remainder (`%`), bitwise operators, and optional chaining (`?.`)
* Regular expressions
* Assigning values, or writing more than one statement
* Functions or text and list methods not listed on this page
* Fields chosen by another field, such as ``a[$`b`]``
* Reading another record, such as a person's company, from a list formula. A list formula reads the record in each row.
* `split(id, salt)`, a function used to divide people into test groups in content routing. It does not work in list filters or columns.

## Related articles

* [What formulas are and when to use one](https://docs.allgoodhq.com/mk/formulas/what-formulas-are.md)
* [How formulas find your data](https://docs.allgoodhq.com/mk/formulas/how-formulas-find-your-data.md)
* [Handle blank and messy values in formulas](https://docs.allgoodhq.com/mk/formulas/handle-blank-values.md)
* [Filter a list with a formula](https://docs.allgoodhq.com/mk/formulas/filter-a-list.md)
* [Formulas FAQ](https://docs.allgoodhq.com/mk/formulas/faq.md)

If a formula you expect to work is rejected, or gives an answer that this page does not explain, contact allGood support. Include the formula, the record you tested it on, and the full error message or the unexpected result.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.