Run conditions

Run conditions are expressions that Databar evaluates for every row before running an enrichment. If the expression returns true, the row is processed. If it returns false, the row is skipped.

This gives you two advantages:

Better data quality: only enrich rows that meet your criteria, so you don’t waste processing on irrelevant data.
Lower cost: skipped rows do not consume credits.

Generate with AI

You don’t need to learn CEL syntax to use run conditions. Databar includes a built-in AI generator that writes the expression for you. Just describe what you want in plain English and the AI will produce the corresponding formula. For example, type “only run on rows where the country is US and the company has more than 50 employees” and the AI will generate {country} == "US" && {employee_count} >= 50.

You can also use LLMs like ChatGPT or Claude to help write CEL expressions. Just describe your table columns and the filtering logic you need.

Syntax basics

Run conditions are written using CEL (Common Expression Language), an open expression language created by Google. To reference a column in your table, type { and select the column name.

{country} == "US" && {employee_count} >= 50

The expression above runs the enrichment only for US-based companies with 50 or more employees.

Operator reference

Comparison operators

Operator	Meaning	Example
`==`	Equal to	`{country} == "US"`
`!=`	Not equal to	`{status} != "inactive"`
`>`	Greater than	`{lead_score} > 80`
`<`	Less than	`{employee_count} < 500`
`>=`	Greater than or equal	`{revenue} >= 1000000`
`<=`	Less than or equal	`{founded_year} <= 2010`

Combining multiple conditions

Use logical operators to chain multiple conditions together in a single run condition expression.

Operator	Meaning	Example
`&&`	AND: all conditions must be true	`{country} == "US" && {employee_count} >= 50`
`\|\|`	OR: at least one condition must be true	`{title} == "CEO" \|\| {title} == "CTO"`
`!`	NOT: exclude rows matching a condition	`!{website}.contains("test")`
`( )`	Group conditions together	`({country} == "US" \|\| {country} == "CA") && {revenue} >= 1000000`

Text operators

Operator	Meaning	Example
`.contains("x")`	True if text contains “x”	`{email}.contains("@gmail.com")`
`.startsWith("x")`	True if text starts with “x”	`{phone}.startsWith("+1")`
`.endsWith("x")`	True if text ends with “x”	`{domain}.endsWith(".io")`
`.size()`	Number of characters	`{email}.size() > 0`
`.matches("regex")`	Regex match	`{email}.matches("^.+@.+\\..+$")`
`.lowerAscii()`	Convert to lowercase	`{country}.lowerAscii() == "us"`
`.upperAscii()`	Convert to uppercase	`{code}.upperAscii() == "USA"`
`+`	Join text	`{first_name} + " " + {last_name}`

Math operators

Operator	Meaning
`+`	Addition
`-`	Subtraction
`*`	Multiplication
`/`	Division
`%`	Modulo (remainder)

List operators

Operator	Meaning	Example
`"x" in list`	True if “x” is in the list	`"VIP" in {tags}`
`.size()`	Number of items	`{tags}.size() > 0`
`.exists(x, condition)`	At least one item matches	`{tags}.exists(t, t.contains("enterprise"))`
`.all(x, condition)`	Every item matches	`{tags}.all(t, t != "")`

Handling empty values

Operator	Meaning	Example
`has(column)`	True if the column has a value	`has({email}) && {email}.contains("@gmail.com")`
`column != ""`	True if not empty text	`{email} != ""`

Always check for empty values before calling text operators like .contains() or .startsWith(). Calling these on an empty cell can cause unexpected behavior.

Examples

Simple conditions (single rule)

Goal	Expression
Only Gmail addresses	`{email}.contains("@gmail.com")`
High-scoring leads	`{lead_score} > 80`
US-based companies	`{country} == "US"`
Skip empty emails	`{email} != ""`
VIP-tagged contacts	`"VIP" in {tags}`
Skip test websites	`!{website}.contains("test")`

Combining two conditions

Goal	Expression
US companies with 50+ employees	`{country} == "US" && {employee_count} >= 50`
Active leads with high scores	`{status} == "active" && {lead_score} > 80`
Email present and valid format	`{email} != "" && {email}.contains("@")`
CEOs or CTOs only	`{title} == "CEO" \|\| {title} == "CTO"`
High revenue or Series B funding	`{revenue} >= 5000000 \|\| {funding_stage} == "Series B"`

Combining three conditions

Goal	Expression
C-level execs at large US companies	`{country} == "US" && {employee_count} >= 500 && {title}.contains("Chief")`
US or Canada, 50+ employees	`({country} == "US" \|\| {country} == "CA") && {employee_count} >= 50`
Active enterprise leads with email	`{status} == "active" && {plan} == "enterprise" && {email} != ""`
Skip test, demo, and example domains	`!{domain}.contains("test") && !{domain}.contains("demo") && !{domain}.contains("example")`

Combining four or more conditions

Goal	Expression
Enterprise targets in North America with budget	`({country} == "US" \|\| {country} == "CA") && {employee_count} >= 200 && {revenue} >= 1000000 && {status} == "active"`
Qualified SaaS leads	`{industry} == "SaaS" && {employee_count} >= 50 && {lead_score} > 70 && has({email})`
Senior decision-makers at funded companies	`({title}.contains("VP") \|\| {title}.contains("Director") \|\| {title}.contains("Chief")) && {funding_stage} != "" && {employee_count} >= 100 && {country} == "US"`

Tips

Test on a small batch first

Before running an enrichment with a new condition across thousands of rows, use the Run single row option or filter your table to a small subset. This lets you verify the condition behaves as expected without spending credits.

Use parentheses to be explicit

When mixing && and ||, wrap groups in parentheses so the evaluation order is clear. Without parentheses, && binds more tightly than ||, which can produce unexpected results.

// Ambiguous
{country} == "US" || {country} == "CA" && {revenue} >= 1000000

// Clear
({country} == "US" || {country} == "CA") && {revenue} >= 1000000

Check for empty values

Use has({column}) or {column} != "" before operating on a column that might be empty. This prevents errors from calling .contains() or .startsWith() on a null value.

Mind your types

CEL is type-aware. If a column stores numbers as text, you may need to convert with int() before comparing:

int({employee_count}) >= 50

Similarly, text comparisons are case-sensitive by default. Use .lowerAscii() to normalize.

Skipped rows are free

Rows that fail a run condition are not sent to the data provider and do not consume credits. Use conditions aggressively to keep costs predictable.

FAQ

Can I use multiple run conditions?

Yes. You combine multiple conditions in a single expression using && (AND) and || (OR) operators. For example, {country} == "US" && {employee_count} >= 50 && {email} != "" checks three conditions at once. There is no limit to how many conditions you can chain together. See Combining multiple conditions for the full syntax.

Do skipped rows cost credits?

No. Rows that fail a run condition are never sent to the data provider and do not consume any credits.

Can I use run conditions with waterfalls?

Yes. Run conditions work with both single enrichments and waterfalls. The condition is evaluated before the waterfall starts, so skipped rows don’t trigger any providers.

Getting Started

Core concepts

Databar on other platforms

Account

Generate with AI

Syntax basics

Operator reference

Comparison operators

Combining multiple conditions

Text operators

Math operators

List operators

Handling empty values

Examples

Simple conditions (single rule)

Combining two conditions

Combining three conditions

Combining four or more conditions

Tips

FAQ

Next steps

Enrichments

Automations

​Generate with AI

​Syntax basics

​Operator reference

​Comparison operators

​Combining multiple conditions

​Text operators

​Math operators

​List operators

​Handling empty values

​Examples

​Simple conditions (single rule)

​Combining two conditions

​Combining three conditions

​Combining four or more conditions

​Tips

​FAQ

​Next steps

Enrichments

Automations

Generate with AI

Syntax basics

Operator reference

Comparison operators

Combining multiple conditions

Text operators

Math operators

List operators

Handling empty values

Examples

Simple conditions (single rule)

Combining two conditions

Combining three conditions

Combining four or more conditions

Tips

FAQ

Next steps