---
title: "Batch Processor"
slug: "batch-processor-input"
updated: 2026-02-26T08:56:21Z
published: 2026-02-26T08:56:21Z
---

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

# Batch Processor

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.

![](https://cdn.document360.io/94808959-fd66-406c-ab5e-4691ce952a14/Images/Documentation/image(213).png)

> [!NOTE]
> 💡Integration Guide
> 
> Composer offers several ways to integrate with external systems — **WebAPI, Connectors, Batches, and Script Engine**. [Read the Integration Guide](https://portal.document360.io/v1/docs/integration-guide) to learn what each does and when to use them.

### 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](/v1/docs/inputs#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](/docs/scene-layers), select the layer you want to label. Ex: ![](https://cdn.document360.io/94808959-fd66-406c-ab5e-4691ce952a14/Images/Documentation/image(214).png)
- 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.

> [!NOTE]
> 💡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

> [!WARNING]
> 💡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](/docs/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.

> [!NOTE]
> ℹ️ 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](/docs/connectors).

**Format:**

```API
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*](/docs/settings-web-api)).
- **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`:

```API
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`.

![](https://cdn.document360.io/94808959-fd66-406c-ab5e-4691ce952a14/Images/Documentation/image(215).png)

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](/docs/connectors).

### Script Engine API

The [Script Engine](/docs/scriptengine) 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](/docs/inputs), [Scene](/docs/scenes), [Operator](/docs/operators-1), [Target](/docs/targets-1), or [Layer](/docs/scene-layers).
- 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:**

```API
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:

```API
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](/docs/scriptengine) doesn’t limit you — only your imagination does.

> [!NOTE]
> 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](/docs/scriptengine).

```javascript
// 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](/docs/webapi), **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](/docs/control-composer-remotely), giving you powerful hands-on control over your workflows.

### Batch API

**Format:**

```API
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`:

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