Built-in Commands

This list of commands is built into Chatty and can't be changed. You can however create your own Custom Commands & Customized Context Menus.

All command names are case-insensitive
Example: Both /me and /ME are the same command
<parameter> represents a required parameter
Example: For /me <message> you need to enter a message: /me likes cheese!
[parameter] represents an optional parameter
Example: For /ban <username> [reason] you don't need to give a reason, but you can: /ban abc spam

Tip: You can also use TAB Completion for many commands. Enter the beginning of a command name (e.g. /sub) and then press TAB to find matching commands (e.g. /subscribers, which allows moderators to turn on sub-only mode).

Chat / Twitch Commands

Moderation

Other Twitch Commands

Settings / Customization Commands

GUI Commands

Manipulate the GUI

Open windows in Chatty

System Commands

Open / affect things outside of Chatty

Learn things about Chatty

Housekeeping Commands

Test Commands

Advanced commands

Execute several commands

The /chain command allows you to run several commands at the same time. Each part separated by a | is basicially entered into the inputbox again.

/chain [command1] | [command2] | [command3]
Runs command1, then command2, then command3. This can be repeated further by adding more parts separated by |.
Whitespace around each command is trimmed.
Note: A | character in a command would be interpreted as a command separator. Escape | with itself to use the character without special meaning (||). If used in a Custom Command, the function $cs() (as in chain safe) can be used around replacements for escaping (e.g. $cs($1-)).

Examples:

/chain /echo a | /echo b
Outputs a and b
/chain /echo a | /echo ||b||
Outputs a and |b|

When using /chain with Custom Command replacements, consider the following:

/chain /echo $cs($(msg)) | /echo abc
All replacements are performed before the /chain command is executed, so anything in $(msg) is put in first. If $(msg) contained Hello World!:
/chain /echo Hello World! | /echo abc
/chain /echo $(msg) | /echo abc
Assuming no escaping were to take place: If $(msg) would contain Hello | World! then the | in it would be interpreted as a command separator and thus World! would be separately entered into the inputbox (so it would output two /echo info messages and send World! to chat):
/chain /echo Hello | World! | /echo abc
This could cause serious issues, so it is recommended to always make sure text is safe to be used in the /chain command: When properly escaped, it will turn into this (which outputs Hello | World! and abc):
/chain /echo Hello || World! | /echo abc
/chain /echo abc $(chain-test)
You can test this by using the $(chain-test) replacement. This should (if e.g. added in the body of a Custom Command) output the following info message:
abc | /echo Test || Message
If you add a backslash in front, it will output two info messages:
abc
Test | Message

Execute the same command for each entry in a list

The /foreach command allows you to run the same command for each entry of a space separated list. The command section is run as a Custom Command, with the $1 replacement containing a single list entry.

/foreach [list] > [command]
The command consist of the comma-separated list, the > character and the command to execute (whereas the command is run as it's own Custom Command with the $1 replacement).
List and command are trimmed for leading and trailing whitespace.
Note: Everything after the first > character is interpreted as the command. If you want to use a > in the list section you have to escape it with itself for it to be treated literally (>>). Both the list and command section will consume a single > only if they are repeated (>> to >, but > unmodified).
If you use a Custom Command replacement in the [list] section, make sure the text is safe to use:

Examples:

/foreach a b c > /echo $1
Outputs a, b and c when entered into the chat inputbox.
//foreach a b c > /echo \$1
Outputs a, b and c when entered into the chat inputbox. Note that the double slash at the start runs this as a Custom Command, so the $1 needs to be escaped, so it is only replaced when the /echo is run for each list entry.
/foreach a <b>> c > /echo $1
Outputs a, <b> and c when entered into the chat inputbox. Note the escaped > in the list entry.
Open Streams=/foreach $fs($1-) > /openUrl https://twitch.tv/\$1 (added as a Streams Context menu entry)
When several channels are selected and the command run, it will replace $1- with the list of selected streams and then open the URL for each one of them. Note that the $1 in the /openUrl command is escaped.

Detailed Explanation Example:

/foreachtest /foreach a b c > /echo \$1 (added to the Custom Commands list)
Outputs a, b and c when /foreachtest is entered into the chat inputbox.
Note the \$1 with the escape character in front, which preserves it for replacement when the /echo is run.

This is what happens when you enter /foreachtest:

  1. Replacements are performed on the Custom Command /foreach a b c > /echo \$1. Since the $1 is escaped it is treated as plain text and not replaced (the \ is consumed).
  2. The result /foreach a b c > /echo $1 is run and the /foreach command will use everything after the > as the Custom Command to run (and trim whitespace).
  3. The Custom Command /echo $1 is run with a as parameter, which results in /echo a being run. The same is repeated for b and c.

If the $1 is not escaped:

  1. Replacements are performed on the Custom Command /foreach a b c > /echo $1. The $1 is replaced with an empty string (no argument given with the /foreachtest command).
  2. The result /foreach a b c > /echo is run and the /foreach command will use everything after the > as the Custom Command to run (and trim whitespace).
  3. The Custom Command /echo is run with a as parameter (although there is no replacement to make use of it), which results in /echo being run, resulting in an error message. The same is repeated for b and c.

If the $1 is not escaped, but you provide a command argument, e.g. /foreachtest 123, then it will replace the $1 with 123 in the first step, so /echo 123 will be run three times.

Run a command in a specific open channel

The /runin command runs a command in the context of a specific open channel, as if you had entered it into the channel's inputbox. Without this, commands usually run in the context of the currently active channel.

/runin [channel] [command]
The channel must be a regular channel with or without leading "#" (#channelname) or a whisper channel ($username).
The command can be anything you could enter into a chat inputbox.

Examples:

/runin #chan2 /echo abc
Outputs the info message "abc" in the channel "#chan2" (if it is open in Chatty).
//runin #chan2 //echo Channel context: \\$(chan) -> \$(chan)
This example is entered directly into a chat inputbox and outputs an info message about the changed channel context in "#chan2". Let's say the command is entered in the channel "#chan1".
The command begins with two slashes (//), so it is interpreted as an anonymous Custom Command: The result /runin #chan2 //echo Channel context: \#chan1 -> $(chan) is run, which runs //echo Channel context: \#chan1 -> $(chan) in "#chan2".
Yet again, the command begins with two slashes (//) and is interpreted as an anonymous Custom Command: The resulting command /echo Channel context: #chan1 -> #chan2 is then run and outputs an info message.

Execute a command on a delay

The /timer command allows you to run a delayed command after a duration or at a certain time. The timed command is run as if it was entered into the inputbox of the same channel that the /timer command was entered in (the command is not run at all if the channel is not a regular channel or not open anymore, unless the -a option is used).

Certain restrictions apply:

/timer [-options] [:id] <duration|time|'list'|'stop'> <timed command>
Optionally one or several options (-rs) can be specified:
The id is used to identify a timer after it has been started (e.g. to stop it). Can be anything (no spaces), if it ends with * an automatically generated number will be appended to make the id unique if used more than once. If no id is specified an automatically generated number without prefix will be used.
The duration is in seconds by default, but you can also append a time unit and several durations that get added up (no spaces):
An absolute time is written like a digital clock in 24hr format, a date can be added in front, in which case it has to be enclosed in [ ]. With no date specified the next occurence of the time is used, so e.g. if it's already in the evening a time of 5 in the morning would be on the next day:
Output info about currently active timers:
Stop active timers: