Skip to content


Filters are a powerful tool to create your own custom, filtered channel splits. Filters allow you to selectively show messages that satisfy your own custom criteria: show subscribers' messages, moderator messages, channel point redemptions, new subscriptions, and more.

Looking for inspiration? Look at some example filters.

Introduction to Filters

Filters can be applied to splits to provide a selective view of messages. Filters are created in the Settings page and are applied by opening the Split menu (three dots) and selecting "Set filters". Applied filters are saved when you close and open Chatterino.

Multiple filters can be applied to a Split. A message must pass all applied filters for it to be displayed.

Simple filters are available through the Channel Filter Creator dialog. Advanced filters take inspiration from many programming languages, and the full description of keywords and operators can be found below.

Writing your own filters

To begin writing your own filters, take a look at the available operators and variables below.

For most tasks involving the message content, you can make use of the contains operator, or the matches operator with a regular expression.
Then, try to break your desired behavior into multiple conditions. Combine them like this:

  • If you need all the conditions satisfied, combine them with AND (condition1 && condition2)
  • If you only need one of the conditions, combine them with OR (condition1 || condition2)
  • If you need the opposite of one of the conditions, wrap it with parentheses and add a NOT: !(condition)


Consider the following intention: "Only show me messages that are from moderators and mention me". We can break this filter into two individual conditions:

  1. Messages that are from moderators
  2. Messages that mention me

We can then write the corresponding filter parts:

  1. author.badges contains "moderator"
  2. message.content contains "@my_name"

Finally, because we want both of these conditions to be true, we combine them with the AND operator && and end up with this final filter:

(author.badges contains "moderator") && (message.content contains "@my_name")

Quick Add

If you already have a filter, you can use the Quick Add button and paste your filter into the Filter section. quickAdd


Here is some terminology that you'll encounter in the rest of this document.

  1. Value: A value is the simplest element of a filter. It can take on multiple forms: a number, a string (i.e. text), a regular expression, or a list of multiple values.
  2. Type: A type describes the general form of a value. For example, every number has type Int. Every string has type String.
  3. Variable: A variable is a placeholder for some information about a message. For example, the variable message.content represents the text of a message
  4. Operator: An operator acts on one or two values and evaluates to another value. For example, the plus operator + can add two numbers, 1 + 1 or concatenate strings, "a" + "b"

Example filters

  • message.content contains "hello"
    • Only messages that contain the phrase hello
  • message.length < 40 || author.subbed
    • Messages that are less than 40 characters long, OR are sent by a subscriber.
  • == "somestreamer" && author.badges contains "moderator"
    • Messages that originated in the channel somestreamer AND are from users with a moderator badge

Filter Syntax + Semantics

This section is aimed at technical users who have experience with general purpose programming languages.

A filter must be a valid expression. An expression is comprised of conditions and values which are evaluated to a single True or False value to decide whether to filter a message. Evaluating to something other than True or False will lead to all messages being filtered out.


A value can be:

  1. An integer (123, 5)
  2. A string ("hello", "this is a string")
  3. A variable (, message.length)
    • Technically, a variable isn't a value, but is given value by substitution
    • When a filter is evaluated, variables are replaced with the values they represent
  4. A regular expression (r"\d\d\d\d")
  5. A list of values ({123, "hello",})

Regular expressions are similar to strings, but are denoted with an r before the opening quotation mark (e.g. r"something"). To make a regular expression case-insensitive, use ri before the opening quotation mark (e.g. ri"something").


Name Example
Int 123, 5
String "Hello there", "Escaped \" quote"
RegEx r"\d\d\d\d", ri"something.*"
List {"list item", 123}


Binary operators act on two values:

  • 1 + 2
  • author.subbed && flags.highlighted
  • "long sentence" contains "ten"

Unary operators act on one value:

  • !author.subbed

The following operators are available:

Operator Description
&& Logical AND
|| Logical OR
! Negation
== Equals
!= Not equals
< Less than
<= Less than or equal to
> Greater than
>= Greater than or equal to
contains String, List, or Map contains
startswith String or List starts with text or value, respectively
endswith String or List ends with text or value, respectively
match Match string with regular expression
+ Add (or string concatenation)
- Subtract
* Multiply
/ Divide (integer)
% Modulus

Please read about the type rules to better understand the evaluation semantics for operators that take multiple data types.


The following variables are available:

Variable Type Description
Author User who sent the message
author.badges List List of author's badges
author.color Color* Color code of author, or none String Display name of author
author.no_color Bool Whether the author has no color set (i.e. gray name)
author.subbed Bool Whether author is subscribed
author.sub_length Int How long author has been subscribed (or zero)
Channel The channel where the message was sent String Channel name
channel.watching Bool Whether the channel is being watched (requires Chatterino extension) Bool Whether the channel is currently live
Flags Message-specific flags
flags.highlighted Bool Whether the message is highlighted
flags.reward_message Bool Whether the message is a redeemed channel point reward message (except "Highlight my Message")
flags.points_redeemed Bool Whether the message was redeemed through the channel point reward "Highlight my Message"
flags.sub_message Bool Whether the message is a sub/resub/gift message
flags.system_message Bool Whether the message is a system message (i.e. timeout/ban/info)
flags.first_message Bool Whether the message is the author's first message in the channel
flags.cheer_message Bool Whether the message includes bits
flags.whisper Bool Whether the message is a whisper
flags.reply Bool Whether the message is a reply
flags.automod Bool Whether the message has automod information or actions
Message Actual message sent
message.content String Message content
message.length Int Message length
Reward Information about the channel point redemption of this message, if any
reward.title1 String Title of the redemption (e.g. Drink water!)
reward.cost1 Int Cost of the redemption (e.g. 500)
reward.id1 String ID of the redemption (e.g. 1ed437f5-9dc3-4510-8a3f-abcad67985e1)

*Note: To compare a Color, compare it to a color hex code string: author.color == "#FF0000"

Data types

The Chatterino filter language is typed, meaning that every value has a type and only specific combinations of types are allowed when using operators. Generally, you won't run in to issues. The type system exists to warn you about any mistakes that your filter contains.

Type Rules

Operator Form Result Description
+ Int + Int Int Adds two integers
+ String + Any String Concatenates the first string with the second argument
- Int - Int Int Subtracts two integers
* Int * Int Int Multiplies two integers
/ Int / Int Int Divides two integers, discarding the remainder
% Int % Int Int Computes the modulus of two integers
&& Bool && Bool Bool Logical AND of two booleans
|| Bool || Bool Bool Logical OR of two booleans
== Any == Any Bool Equality comparison of any two values
!= Any != Any Bool Inequality comparison of any two values
> Int > Int Bool Greater than comparison of two integers
>= Int >= Int Bool Greater than or equal to comparison of two integers
< Int < Int Bool Less than comparison of two integers
<= Int <= Int Bool Less than or equal to comparison of two integers
startswith List startswith Any Bool Checks whether the list has the given value as its first value
startswith String startswith String Bool Checks whether the first string starts with the second string
endswith List endswith Any Bool Checks whether the list has the given value as its last value
endswith String endswith String Bool Checks whether the first string ends with the second string
contains List contains Any Bool Checks whether the list contains the given value
contains Map contains Any Bool Checks whether the map has the given value as a key
contains String contains String Bool Checks whether the first string contains the second string
match String match RegEx Bool Checks whether the string matches the given regular expression
match String match {RegEx, n : Int} String Returns the nth matching capture group, or the empty string

Regular Expressions

Chatterino can match string variables to a regular expression, returning whether the expression matched or, optionally, the value of a capture group.

Simple matching

"some string" match r"some regex" returns True or False.

For example: message.content match r"\d\d"

Group capturing

"some string" match {r"some regex", capture number} returns False if no match or the value of the nth captured group.

For example: message.content match {r"(\d\d)/(\d\d)/(\d\d\d\d)", 3} matches the year component of a date like 12/31/2020.

(message.content match {r"(\d\d)/(\d\d)/(\d\d\d\d)", 3}) == "2020" will filter only messages that contain a written date with 2020 as the year.

Order of Operations

The order of operations in filters may not be exactly what you expect.

  • Expressions in parentheses are evaluated first
  • Math operations are evaluated from left to right, not by MDAS. 2 + 3 * 4 yields 20, not 14.
  • a && b || c && d is evaluated as (a && b) || (c && d)
  • a || b && c || d is evaluated as a || (b && c) || d

Basically, if you're unsure about the order of operations, use extra parentheses.

  1. Available since 2.5.1