Batch Processor

Prev Next

The Batch Processor Input is a special input that acts as a bridge between Connectors and your Scene Layers, allowing you to control multiple layers across different scenes with a single command. Instead of manually hiding or showing layers one by one, you can give them a shared batch name and then control them all at once.

You can:

  • Show them (make them all visible),

  • Hide them (make them all invisible), or

  • Solo them (make only those layers visible, while hiding everything else).

This makes it much easier to switch groups of layers on and off across multiple scenes, especially during live productions.

Options

  • Batch command - Choose what action the Batch Processor should perform.

    • SHOWLAYER - Makes all matching scene layers visible. Use this if you want to show several tagged scene layers at once.

    • HIDELAYER – Hides all matching scene layers. Use this when you want to remove several tagged scene layers with one action.

    • SHOWLAYERSOLO - Shows only the matching scene layers and hides everything else. This is useful if you want to focus on one group of scene layers (for example, just the “FrontCam” group) while hiding all other content in the scene.

  • Batch name - The name (or tag) of the batch you want to control. All scene layers with this batch name will be affected.

  • Scene name (optional) - If you want to limit the command to a specific Scene, enter its name here. Leave empty to include all Scenes.

  • Comparison type - Decides how the batch name is matched against the scene layer Batch field names:

    • Contains – Matches if the name contains the text.

    • Equal – Matches if the name is exactly the same.

    • StartsWith – Matches if the name begins with the text.

    • EndsWith – Matches if the name ends with the text.

  • Test batch command - Runs the selected command immediately, so you can confirm that your batch settings work as expected.

Option TAGS

TAGS - Add a "tag"  that can be used in the input smart search function. It is possible to add several tags by separating them with a SPACE character.

Getting Started

To make the Batch Processor useful, you first need to add batch names to your scene layers. A batch name is simply a label (one or more words) that you assign to a layer. Later, the Batch Processor can find and control all scene layers with that label.

How to add a Batch name to a layer

  • In Scene Layers, select the layer you want to label. Ex:

  • In the layer properties, locate the Batch field.

  • Type in one or more names. Separate each name with a space.

    Example: MainOverlay Scoreboard Timer

    In this case, the layer will belong to all three groups: MainOverlay, Scoreboard, and Timer.

  • Repeat for other layers you want to group.

💡Tip

Batch names are case-insensitive, and you can assign unlimited names. Treat them like tags for flexible grouping.

Once you’ve added Batch names to your scene layers, you can control them all together with the Batch Processor input.

Example of Comparison Types

💡When configuring comparisons, remember:

  • Batch name → the value you set in the Batch Processor input.

  • Scene Layer Batch field → the Batch property on each Scene Layer that gets compared against the Batch Processor Batch name.

  • Contains

    • Batch Processor Batch name set to: Cam

    • Scene Layer with a Batch field like FrontCam, Cam2, or BackupCamera will all match.

  • Equal

    • Batch Processor Batch name set to: MainOverlay ScoreBoard

    • Matches a Scene Layer whose Batch field is exactly MainOverlay ScoreBoard (case-insensitive, spaces included).

    • Example:

      • A Scene Layer with its Batch field MainOverlay will NOT match, since it’s missing ScoreBoard.

      • A Scene Layer with its Batch field  MainOverlay scoreboard WILL match (case does not matter).

  • StartsWith

    • Batch Processor Batch name set to: Intro

    • Scene Layers with Batch fields like IntroTitle, Intro Logo, or Intro Animation Background will match.

  • EndsWith

    • Batch Processor Batch name set to: Overlay

    • Scene Layers with Batch fields ScoreOverlay, Timer Overlay, or video logo overlay will match.

Execute Batch Commands With Connectors API

The Connectors API lets you trigger and update Connectors that you’ve already configured in Composer. Connectors act as bridges to external data sources (such as APIs, scoreboards, or custom feeds) and can automatically drive your graphics with live data.

ℹ️ Info

This example assumes that you already have Connectors set up and know how to configure them. For detailed setup and configuration instructions, see the Connectors documentation.

Format:

http://YOURIP:PORT/api/connector/trigger?[TRIGGER_TYPE]=[CONNECTOR_NAME]

Parameters:

  • YOUR_IP – The IP address of the system running Composer, e.g., 127.0.0.1

  • PORT – The Composer API port. Default is 44433 (configurable in Settings).

  • TRIGGER_TYPE – Defines how the Connector should be matched:

    • name → Triggers a connector by its Name (evaluation always equals).

    • value → Triggers a connector by its Value (supports Equals, Contains, EqualsNot, ContainsNot).

Example: Send an API request to trigger a Connector by its name, eg,. MyConnector:

http://127.0.0.1:44433/api/connector/trigger?name=MyConnector

The above API command will trigger MyConnector configured to solo all scene layers with batch fields starting with Cam3.

Connectors can also accept custom parameters from API calls to make them more dynamic.
You can pass any number of parameters in the request and reference them inside the Connector by prefixing their names with @@ (for example, @@MyParameter).

For examples and details on how to use parameters in your Connectors, see the Connectors documentation page.

Script Engine API

The Script Engine lets you extend Composer with your own custom logic using JavaScript. With it, you can automate tasks, react to incoming data, or create intelligent workflows that go beyond the standard inputs and buttons.

The Script Engine API makes this even more powerful by allowing external systems to send messages (for example, from a scoreboard system, a graphics controller, or your own software) directly into your scripts. Your script can then parse the message, make decisions, and trigger commands inside Composer — all in real time.

Think of it as your bridge between Composer and the outside world:

  • Composer → Script: Use JavaScript to access and control any Input, Scene, Operator, Target, or Layer.

  • Outside → Script: Send messages to the Script Engine API and let your script decide what to do with them.

This combination gives you maximum flexibility to build custom automations tailored to your live production.

Format:

http://[YOUR_IP:PORT]/api/scriptengine/execute?function=[FUNCTION_NAME]&parameter=[PARAMETER]

Parameters:

  • YOUR_IP – The IP address of the system running Composer, e.g., 127.0.0.1

  • PORT – The Composer API port. Default is 44433. This can be changed in Settings.

  • FUNCTION_NAME – The actual name of your JavaScript function to be invoked, e.g., MyFunction

  • PARAMETER – The parameter to be passed into the JavaScript function. If you need to send several parameters, pass them as a JSON object.

Example: Send an API request to a JavaScript function that uses the Batch Processor. This allows you to build flexible workflows and automate how layers are shown, hidden, or soloed across your scenes.

API request for the JavaScript function below:

http://127.0.0.1:44433/api/scriptengine/execute?function=MyFunction&parameter={"command":"show","name":"FrontCam","scene":"","comparison":"contains"}

  • This request calls the JavaScript function MyFunction inside Composer.

  • It passes in a JSON parameter telling the Batch Processor to show all layers where the batch name contains FrontCam.

  • Because scene is left blank, the command applies to all scenes.

💡 This JSON structure is just one example. You are free to design your own JSON format and handle it however you like in your script. Maybe you add extra fields, maybe you rename them, or maybe you add entirely new logic. The Script Engine doesn’t limit you — only your imagination does.

The JavaScript example below serve as a starting point or boilerplate for controlling Composer. The example is meant to help you get up and running quickly and can be extended or customized to build your own workflows using the Script Engine.

// Get reference to the Batch Processor input
const batchProcessor = Project.GetInputByName("Batch Processor");

// Map API-friendly command strings to Batch Processor command IDs
const commandMap = {
    "show": 0,         // SHOWLAYER
    "hide": 1,         // HIDELAYER
    "solo": 2          // SHOWLAYERSOLO
};

// Map comparison strings to Batch Processor comparison IDs
const comparisonMap = {
    "contains": 0,     // default
    "equal": 1,
    "startswith": 2,
    "endswith": 3
};

function MyFunction(message) {
    // Example incoming JSON message:
    // {"command":"show","name":"FrontCam","scene":"","comparison":"contains"}

    // Parse message into an object
    const json = JSON.parse(message);

    // Default to "solo" (2) if no match is found
    const batchCommandEnumId = commandMap[json.command?.toLowerCase()] ?? 2;

    // Default to "contains" (0) if no match is found
    const comparisonEnumId = comparisonMap[json.comparison?.toLowerCase()] ?? 0;

    // Apply values to the Batch Processor
    batchProcessor.BatchCommand = batchCommandEnumId;
    batchProcessor.BatchName = json.name ?? "";
    batchProcessor.SceneName = json.scene ?? "";
    batchProcessor.BatchComparisonType = comparisonEnumId;

    // Execute the configured batch command immediately
    Project.ExecuteInputCommand(batchProcessor, "TestBatchCommand");

    // Do other work if needed...
}

API Integration

Batches can also be controlled remotely via Composer’s API, without the Batch Processor Input. This makes it easy to integrate with external systems, automation tools, or custom control panels such as Stream Deck devices via Companion, giving you powerful hands-on control over your workflows.

Batch API

Format:

http://[YOUR_IP:PORT]/api/batch/[ACTION_TYPE]?batch=[BATCH_NAME]&scene=[SCENE_NAME]&comparison=[COMPARISON_TYPE]

Parameters:

  • YOUR_IP – The IP address of the system running Composer, e.g., 127.0.0.1

  • PORT – The Composer API port. Default is 44433. This can be changed in Settings.

  • ACTION_TYPE – What you want to do with the matching layers:

    • showlayersolo – Show only the matching layers and hide all others.

    • showlayer – Show the layers.

    • hidelayer – Hide the layers.

  • BATCH_NAME – The batch name (or names) to target.

  • SCENE_NAME (optional) – Restrict the command to a specific scene. Leave out to include all scenes.

  • COMPARISON_TYPE – How to compare the batch name with the layer’s batch field:

    • contains

    • equal

    • startswith

    • endswith

Example: Show all scene layers with the batch field Scoreboard in Scene GameScene, matching scene layer Batch fields that contain Scoreboard:

http://127.0.0.1:44433/api/batch/showlayer?batch=Scoreboard&scene=GameScene&comparison=contains