Software

• 1: IDFM
• 1.1: Install
• 1.2: Discover and IP
• 1.3: Firmware
• 1.4: Troubleshoot
• 2: Maxx Control (MaxxControl)
• 2.1: REST API
• 2.1.1: Maxx Control REST: Set channel names
• 2.1.2: Maxx Control REST: Control device mute and volume
• 2.1.3: Device Information
• 2.1.4: Maxx Control REST: Enable or disable EQ
• 2.1.5: Mute Control
• 2.1.6: Volume Control
• 2.1.7: AES67 / SDP subscribe
• 2.1.8: Maxx Control REST: Switch input patches
• 2.1.9: Amp enable
• 2.1.10: Save / persist
• 2.2: Third Party Plugins
• 2.2.1: Loxone Maxx Control plugin
• 2.2.2: Q-SYS Maxx Control plugin
• 3: Maxx Remote
• 3.1: Concept
• 3.2: Installation
• 3.3: Prerequisites
• 3.4: Quick-Start
• 3.5: Projects
• 3.6: Build a system
• 3.6.1: Channels and groups
• 3.6.2: Devices and linking
• 3.6.3: Inputs and routing
• 3.6.4: Tuning
• 3.7: Everyday control
• 3.8: Advanced
• 3.8.1: Multi-way channels
• 3.8.2: Surround input sources
• 3.8.3: Speaker presets
• 3.9: Troubleshoot
• 3.10: GUI reference
• 3.10.1: HOME
• 3.10.2: DEVICES
• 3.10.3: INPUTS
• 3.10.4: CHANNELS
• 3.10.5: GROUPS
• 3.10.6: CROSSMIX
• 3.10.7: SIG-PATH
• 3.10.8: VIEW
• 3.10.9: LOG
• 3.11: API
• 3.11.1: REST API
• 3.11.2: Maxx Remote View API
• 3.11.3: Group signal path

1 - IDFM

IDFM (Innosonix Device and Firmware Manager) is a desktop Electron app for bringing amplifiers onto a working network plan and keeping firmware current. Use it before Maxx Control or Maxx Remote. That workflow includes micro MAXX and other MAXX amplifiers.

When to use which tool

Download

Get IDFM from the Innosonix downloads page (IDFM tab):

Product overview: innosonix.de/software.

Recommended path

1. Install IDFM and confirm UDP STATUS.
2. Discover devices and set IP (hostname / identify as needed).
3. Update firmware if newer images are available.
4. Continue with Maxx Control (single amp) or Maxx Remote (multi-amp).

How discovery works

IDFM has two ways to get devices into the list — they are not two equal “discovery protocols”:

Routers do not forward UDP broadcast. Across VLANs, use add-by-IP or range scan — see Discover and IP.

Ports (PC ↔ amplifier)

Some update paths also use HTTP 8080 on the device for file upload. Allow these in the PC firewall (and between VLANs when you use scan/add).

In this section

1.1 - Install

Goal / when to use

Get IDFM running on the PC you will use for commissioning so amplifiers can be discovered and configured.

Download

1. Open the Innosonix downloads page.
2. Select the IDFM tab.
3. Download the build for your OS:

IDFM may offer an in-app update when a newer tool version is published on the download service.

First launch

1. Start IDFM.
2. Open the DEVICES page (default).
3. Check UDP STATUS (top right).
4. Confirm devices appear, or that the status does not show UDP blocked / port unavailable.

Expected result

The device table loads. Online count updates as amps answer discovery. If nothing appears yet, continue with Discover and IP (same L2 segment, or add/scan).

Firewall and UDP status

Automatic discovery uses UDP 9453. The PC firewall must allow IDFM to send and receive that traffic on your control network.

• Use UDP STATUS to see whether discovery sockets are healthy on local interfaces.
• If another IDFM instance is already running, you may see a port already in use message — quit the other instance.
• Windows: if devices never appear, open HELP in IDFM. The FAQ can re-apply Windows firewall allow rules for the app, or (last resort) temporarily disable the firewall profile while diagnosing. Prefer fixing rules over leaving the firewall off.

Related links

• IDFM overview
• Discover and IP
• Firmware
• Troubleshoot

1.2 - Discover and IP

Goal / when to use

Put every amplifier on the site IP plan: discover (or add) devices, set STATIC-IP or DHCP, name them, and confirm which physical unit is which.

Prerequisites

• IDFM installed with healthy UDP STATUS when you expect automatic discovery
• PC on the same L2 segment as the amps for UDP broadcast, or known amp IPs / reachable routed subnet for add/scan

UDP discovery (preferred)

On the same switch / VLAN, IDFM discovers amps with UDP broadcast on port 9453 (255.255.255.255).

1. Open DEVICES.
2. Wait for rows to appear (hostname, model, firmware, IP, status).
3. Filter or sort the table if you have many units.

UDP discovery still works when the amp’s configured IP is on a different subnet than the PC — as long as they share the same broadcast domain. That is how you recover “wrong IP” units without serial console access.

Example (wrong subnet, same switch)

PC:         192.168.0.33 / 255.255.255.0
Amplifier:  192.168.99.2 / 255.255.255.0

Unicast HTTP may fail, but UDP discovery can still list the amp and accept a new IP configuration.

Expected result

Amps show as online in the list. You can open IP / hostname dialogs from the row.

Set IP (STATIC or DHCP)

1. Click the IP cell for the device.
2. Choose TYPE:
   • STATIC-IP — enter IP, subnet, gateway
   • DHCP — device takes an address from the DHCP server
3. Click SET.
4. Optional on DHCP: NEW DHCP LEASE to renew.

After a STATIC change, wait a few seconds for the list to refresh. After DHCP, the old address may go offline until the amp reappears with the new lease.

Hostname and identify

Add by IP or subnet scan (routed networks)

Routers do not forward UDP broadcast. If the PC and amps are on different routed VLANs, use + above the device list:

1. Add by IP — enter a known amplifier IP (device must answer ping / HTTP).
2. Subnet scan — enter the first three octets of the target /24 (for example 192.168.99) and scan. IDFM probes live hosts via the device HTTP REST API.

Example (routed VLANs)

VLAN1: PC          192.168.0.33 / 24
         |
       ROUTER
         |
VLAN2: Amplifier   192.168.99.2 / 24

Scan or add in 192.168.99.0–255. After add, configure IP/hostname as needed (unicast path must reach the amp).

Expected result

Added devices appear in the list (often marked as manually added). Save the list if you want them remembered on next launch.

List tools

On DEVICES you can save, clear, or export the current device list. Saving helps when you rely on manually added units across sessions.

Related links

• Install
• Firmware
• Troubleshoot
• Maxx Remote · Prerequisites

1.3 - Firmware

Goal / when to use

Bring amplifiers to a known, current firmware before commissioning with Maxx Control or Maxx Remote.

Prerequisites

• Devices listed and reachable in Discover and IP
• For a successful update, the PC and amplifier should share a reachable unicast path on the same subnet (loader / update traffic is not the same as UDP discovery-only)
• Internet on the PC to fetch images from Innosonix, or .inx files copied from another machine

Check for updates

1. Start IDFM with network access.
2. Open the FIRMWARE tab. A red badge can indicate newer images are available to download.
3. The FIRMWARE UPDATES control (when shown) summarizes devices that have a newer release than they are running.

IDFM compares discovered device versions against the firmware catalog and images you have stored locally.

Download firmware (online)

1. Open FIRMWARE.
2. Download the images you need for the models on site.
3. Files are kept on the PC so you can update later without internet.

Local store (created by the app):

~/Innosonix/IDFM/firmwareStorageFolderIDFM/

(On Windows, under your user home directory with the same folder names.)

Import firmware (offline)

When the commissioning PC has no internet:

1. On a connected machine, download .inx files from the downloads page (or download them inside IDFM and copy from the store above).
2. Transfer via USB or similar.
3. In IDFM FIRMWARE, import the .inx file(s).

Update devices

1. On DEVICES, select the units to update (or open update from the toolbar).
2. Choose UPDATE DEVICES / the firmware update flow.
3. Confirm the target image per model.
4. Start the update and wait until each unit finishes and returns to a running state.

You can update multiple devices in one session when images are already local.

Expected result

Device firmware columns show the new version. Amps reboot as required and come back online in the list.

Manual bootloader fallback (MAXX²)

On MAXX² amplifiers with a front-panel display (for example MA32/D², MA32/LP², and similar models), you can force the device into bootloader mode from the front panel. Use this when you want more manual control over the update workflow, or as a recovery path when a normal update does not start.

Steps

1. Power the amplifier off.
2. Hold ESC + OK on the front panel.
3. Power the amplifier on while keeping ESC + OK held until it enters bootloader mode.
4. In IDFM, select the device and run the firmware update with the correct .inx image (see Update devices above).

Expected result

The amp appears ready for an IDFM update from bootloader / loader state. After the update finishes, it returns to a normal running status.

Related links

• Discover and IP
• Troubleshoot
• Maxx Remote · Prerequisites

1.4 - Troubleshoot

Goal / when to use

IDFM does not list a device, UDP looks broken, or a firmware update fails. Match the symptom below.

Device missing from the list

Symptoms

DEVICES stays empty or omits a known amp.

Steps

1. Confirm PC and amp share the same L2 segment if you expect UDP discovery.
2. Check UDP STATUS — see Install.
3. Windows: use HELP → FAQ actions to re-apply firewall allow rules for IDFM.
4. If you know the IP, use + → add by IP.
5. If the amp is on another routed subnet, use subnet scan — broadcast will not cross the router.
6. Confirm only one IDFM instance is running.

Expected result

The amp appears via UDP or as a manually added / scanned device.

Port already in use

Symptoms

Message that the required port is already in use.

Steps

1. Quit other IDFM windows / instances.
2. Restart IDFM.
3. If it persists, check whether another tool on the PC is bound to UDP 9453.

Expected result

Discovery starts; UDP STATUS is healthy.

Routed VLANs / no automatic discovery

Symptoms

Amps never appear until you type an IP; Maxx Remote discovery is also empty on the same PC.

Why

UDP broadcast (9453 to 255.255.255.255) stops at routers. That is expected.

Steps

1. Add by IP or scan the remote /24 — see Discover and IP.
2. Ensure the PC can ping and reach device HTTP (REST) on that VLAN.
3. After IP plan is correct, Maxx Remote can use manual add the same way — see Maxx Remote · Prerequisites.

Firmware update fails

Symptoms

Update warning about subnet / reachability; device stuck in loader; progress never finishes.

Steps

1. Put the PC on the same subnet as the amp management IP (unicast path for loader TCP 9454 / update). UDP discovery alone is not enough.
2. Download or import the correct .inx for that model first (FIRMWARE tab).
3. If the unit is already waiting in the loader and still unreachable from your current network, connect the PC directly to the amp (or fix routing) and retry.
4. Do not power-cycle during the update unless support instructs you to.
5. If you need a more manual recovery path on a MAXX² front-panel amp, force bootloader mode with ESC + OK at power-up, then update from IDFM — see Manual bootloader fallback.

Expected result

Update completes; device returns to a running status with the new version.

Related links

• Install
• Discover and IP
• Firmware
• Maxx Remote · Troubleshoot

2 - Maxx Control (MaxxControl)

Maxx Control (also written MaxxControl) is the control surface built into every Innosonix amplifier: a browser web UI plus an open REST API on the device. Use it for one amplifier when you want local control with no desktop install, or when a media-control / home-automation system should talk to a single amp. That includes micro MAXX — same webpage and API as other MAXX models. For many amplifiers, rooms/groups, and offline projects, use Maxx Remote instead.

When to use what

Access (brief)

1. Set a reachable IP (and hostname) with IDFM, or use the address shown on the device front panel.
2. Open the UI in a browser: http://<ip>/ (many networks also accept http://<hostname>.local/).
3. On-device REST documentation (full OpenAPI / Swagger): OVERVIEW page → REST API DOC (lower right), served as http://<ip>/…/doc/maxx_rest_api.html.

HTTP is on port 80. The API base path is /rest-api.

What this docs site covers

This section focuses on REST API usage for integrators and third-party systems, plus third-party plugins that wrap that API.

Start here

1. REST API overview — auth, hierarchy, OPTIONS, where the full schema lives
2. REST API use cases — mute, volume, status, save, EQ, and more under Common use cases
3. AES67 / SDP subscribe — patch a channel to an AES67 / SDP stream
4. Third-party plugins — Q-SYS, Loxone, and similar (single device each)

2.1 - REST API

Every amplifier exposes a hierarchical JSON REST API used by Maxx Control itself and by third-party systems. Prefer this API for single-device integration. For project-level multi-amp control, use the Maxx Remote HTTP API instead.

Base URL and transport

Methods you will use most: GET (read), PUT (write / partial update), OPTIONS (allowed ranges and constraints), plus POST / DELETE on a few resources (for example EQ bands).

Authentication

Write operations that change settings require an API key in the HTTP header:

Defined in OpenAPI as ApiKeyAuth (token in header). GET and most OPTIONS calls do not require the token. Most PUT (and many DELETE) calls do — check the on-device OpenAPI for each path; a few DELETE endpoints are unauthenticated in the schema.

curl -X PUT "http://${IP}/rest-api/settings/channel/1/dsp/mute" \
  -H "token: f4005bf8507999192162d989d5a60823" \
  -H "Content-Type: application/json" \
  -d '{"value": true}'

Hierarchical resources

The tree is organized under /settings (configuration), /status (live state), /info, /preset, and helpers such as /speakerpreset. Channel resources nest DSP blocks (volume, mute, EQ, FIR, limiters, …); device resources cover master mute/volume, Dante, network, and more.

You can:

• PUT a deep leaf, e.g. …/settings/channel/1/dsp/mute
• PUT a parent with a partial JSON object, e.g. …/settings/channel with an array of channel objects
• PUT …/settings with a larger tree when you need a wide update in one call

Example shape under settings (not exhaustive):

settings/
  channel/
    {channel_id}/
      ampenable
      dsp/
        delay | eq | eqenable | fir | mute | volume | …
  device/
    dsp/ (mute, volume, …)
    dante/
    network/
    …

Partial updates are the normal pattern: send only the fields you want to change.

OPTIONS = parameter constraints

OPTIONS on a resource returns the allowed parameter space for that property (min / max / step / unit, enums, string lengths, and similar). Use it when building UIs or validating values before PUT — especially for volume, delay, limiters, and names.

Example: discover channel volume limits:

curl -X OPTIONS "http://${IP}/rest-api/settings/channel/1/dsp/volume"

Exact response fields vary by resource; see the on-device OpenAPI schemas (for example NumberOptions).

Full OpenAPI (source of truth)

This site documents common integrator patterns. The complete, firmware-matching schema is on the device:

1. Open Maxx Control → OVERVIEW
2. Click REST API DOC (lower right)

That opens the Swagger UI for maxx_rest_api.html (generated from the device OpenAPI). Always trust the on-device docs for path lists and schemas for your firmware version.

Common use cases

Third-party plugins (Q-SYS, Loxone, …) use this same API against one amplifier each — see Third-party plugins.

2.1.1 - Maxx Control REST: Set channel names

Use the Maxx Control REST API to get and set channel names so zones and automation UIs stay readable. Names can contain alphanumeric characters, spaces, and special characters.

Get Channel Name

Retrieve the current name of a channel:

• GET Request
• Response Example

curl -X 'GET' http://${IP}/rest-api/settings/channel/1/name

{
  "value": "Living Room Left"
}

Set Channel Name

Set or update the name of a channel. Channel names can be up to 256 characters and support:

• Letters (a-z, A-Z)
• Numbers (0-9)
• Spaces
• Special characters: äöü:_()!%+*#-

• PUT Request
• JSON Payload

curl -X 'PUT' http://${IP}/rest-api/settings/channel/1/name \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "value": "Living Room Left"
}'

{
  "value": "Living Room Left"
}

Set Multiple Channel Names

Set names for multiple channels in a single request:

• PUT Request
• JSON Payload

curl -X 'PUT' http://${IP}/rest-api/settings/channel/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '[
  {
    "channel_id": 1,
    "name": {
      "value": "Living Room Left"
    }
  },
  {
    "channel_id": 2,
    "name": {
      "value": "Living Room Right"
    }
  },
  {
    "channel_id": 3,
    "name": {
      "value": "Kitchen"
    }
  },
  {
    "channel_id": 4,
    "name": {
      "value": "Bedroom"
    }
  }
]'

[
  {
    "channel_id": 1,
    "name": {
      "value": "Living Room Left"
    }
  },
  {
    "channel_id": 2,
    "name": {
      "value": "Living Room Right"
    }
  },
  {
    "channel_id": 3,
    "name": {
      "value": "Kitchen"
    }
  },
  {
    "channel_id": 4,
    "name": {
      "value": "Bedroom"
    }
  }
]

Get Maximum Channel Name Length

Check the maximum allowed length for channel names:

• OPTIONS Request
• Response Example

curl -X 'OPTIONS' http://${IP}/rest-api/settings/channel/1/name

{
  "length": 256
}

Example: Naming a Multi-Zone Setup

Here’s a practical example for naming channels in a multi-zone audio system:

• PUT Request
• JSON Payload

curl -X 'PUT' http://${IP}/rest-api/settings/channel/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '[
  {
    "channel_id": 1,
    "name": {
      "value": "Zone 1 - Main"
    }
  },
  {
    "channel_id": 2,
    "name": {
      "value": "Zone 2 - Kitchen"
    }
  },
  {
    "channel_id": 3,
    "name": {
      "value": "Zone 3 - Bedroom"
    }
  },
  {
    "channel_id": 4,
    "name": {
      "value": "Zone 4 - Office"
    }
  }
]'

[
  {
    "channel_id": 1,
    "name": {
      "value": "Zone 1 - Main"
    }
  },
  {
    "channel_id": 2,
    "name": {
      "value": "Zone 2 - Kitchen"
    }
  },
  {
    "channel_id": 3,
    "name": {
      "value": "Zone 3 - Bedroom"
    }
  },
  {
    "channel_id": 4,
    "name": {
      "value": "Zone 4 - Office"
    }
  }
]

Tip: Use descriptive channel names to make your system easier to manage, especially when integrating with home automation systems or control interfaces.

2.1.2 - Maxx Control REST: Control device mute and volume

Use the Maxx Control REST API to set device-level master mute, master volume, and startup mute on one amplifier. These controls affect all channels globally — useful for emergency mute, master volume, and safe startup behavior.

Device Mute

The device mute acts as a master mute that affects all channels, regardless of individual channel mute settings.

Get Device Mute State

• GET Request
• Response Example

curl -X 'GET' http://${IP}/rest-api/settings/device/dsp/mute

{
  "value": false
}

Set Device Mute

• Mute All Channels
• Unmute All Channels

curl -X 'PUT' http://${IP}/rest-api/settings/device/dsp/mute \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "value": true
}'

curl -X 'PUT' http://${IP}/rest-api/settings/device/dsp/mute \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "value": false
}'

Device Volume

The device volume acts as a master volume control that affects all channels. Individual channel volumes are relative to this setting.

Get Device Volume

• GET Request
• Response Example

curl -X 'GET' http://${IP}/rest-api/settings/device/dsp/volume

{
  "value": 0.0
}

Set Device Volume

• PUT Request
• JSON Payload

curl -X 'PUT' http://${IP}/rest-api/settings/device/dsp/volume \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "value": -5.0
}'

{
  "value": -5.0
}

Note: Device volume range is -72.0 dB to +24.0 dB. This setting affects all channels globally.

Startup Mute

Configure whether the device should start muted after a reboot or power cycle.

Get Startup Mute Setting

• GET Request
• Response Example

curl -X 'GET' http://${IP}/rest-api/settings/device/dsp/startupmute

{
  "value": false
}

Set Startup Mute

When enabled, the device will start muted after reboot or power cycle:

• Enable Startup Mute
• Disable Startup Mute

curl -X 'PUT' http://${IP}/rest-api/settings/device/dsp/startupmute \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "value": true
}'

curl -X 'PUT' http://${IP}/rest-api/settings/device/dsp/startupmute \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "value": false
}'

Use Case: Enable startup mute to prevent audio from playing immediately after power restoration, giving you time to verify system status before audio begins.

Complete Device Control Example

Here’s an example that combines multiple device-level controls:

• Example: Safe Startup Configuration

# Set device to start muted
curl -X 'PUT' http://${IP}/rest-api/settings/device/dsp/startupmute \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{"value": true}'

# Set master volume to a safe level
curl -X 'PUT' http://${IP}/rest-api/settings/device/dsp/volume \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{"value": -10.0}'

# Unmute device when ready
curl -X 'PUT' http://${IP}/rest-api/settings/device/dsp/mute \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{"value": false}'

2.1.3 - Device Information

Getting Device Information

The device information endpoint provides details about your amplifier model, available channels, installed options, and hardware features.

Get Device Information

Retrieve all device information with a simple GET request:

• GET Request
• Response Example

curl -X 'GET' http://${IP}/rest-api/info/device

{
  "model_name": "MA32D",
  "channel": 32,
  "options": ["IF1", "IF2", "D1", "D2"],
  "psu_fan": true,
  "housing_fan": true
}

Understanding the Response

• model_name: The amplifier model (e.g., MA32D, MA32LP, MA24D2)
• channel: Number of available channels (16-32)
• options: Array of installed options:
  • IF1, IF2, IF3: Interface options
  • D1, D2, D3: Dante options
  • M1: Additional options
• psu_fan: Whether PSU fan is installed
• housing_fan: Whether housing fan is installed

This information is useful for:

• Verifying device capabilities before making API calls
• Determining available channel count
• Checking installed hardware options
• Building device-specific automation logic

Status snapshot

Read calls do not need the token.

GET /status returns the full status tree (channels, device, interfaces, save state, syslog summary).

curl "http://${IP}/rest-api/status"

Health-oriented errors

GET /status/error aggregates channel and device errors with severity and status_flags (error / warning / ok).

curl "http://${IP}/rest-api/status/error"

Narrower reads are available, for example GET /status/device or GET /status/channel/{channel_id} — see on-device OpenAPI.

2.1.4 - Maxx Control REST: Enable or disable EQ

Use the Maxx Control REST API to enable or disable channel EQ (eqenable) — bypass the whole equalizer for testing or mode changes while keeping filter settings intact.

Enable EQ for Multiple Channels

Enable the equalizer for multiple channels in a single request:

• PUT Request
• JSON Payload

curl -X 'PUT' http://${IP}/rest-api/settings/channel/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '[
  {
    "channel_id": 1,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  },
  {
    "channel_id": 2,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  },
  {
    "channel_id": 3,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  }
]'

[
  {
    "channel_id": 1,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  },
  {
    "channel_id": 2,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  },
  {
    "channel_id": 3,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  }
]

Disable EQ for Multiple Channels

Disable the equalizer for multiple channels:

• PUT Request
• JSON Payload

curl -X 'PUT' http://${IP}/rest-api/settings/channel/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '[
  {
    "channel_id": 1,
    "dsp": {
      "eqenable": {
        "value": false
      }
    }
  },
  {
    "channel_id": 2,
    "dsp": {
      "eqenable": {
        "value": false
      }
    }
  },
  {
    "channel_id": 3,
    "dsp": {
      "eqenable": {
        "value": false
      }
    }
  }
]'

[
  {
    "channel_id": 1,
    "dsp": {
      "eqenable": {
        "value": false
      }
    }
  },
  {
    "channel_id": 2,
    "dsp": {
      "eqenable": {
        "value": false
      }
    }
  },
  {
    "channel_id": 3,
    "dsp": {
      "eqenable": {
        "value": false
      }
    }
  }
]

Single Channel EQ Control

Enable or disable EQ for a single channel:

• Enable EQ
• Disable EQ

curl -X 'PUT' http://${IP}/rest-api/settings/channel/1/dsp/eqenable \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "value": true
}'

curl -X 'PUT' http://${IP}/rest-api/settings/channel/1/dsp/eqenable \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "value": false
}'

Get EQ Enable State

Check if EQ is enabled for a channel:

• GET Request
• Response Example

curl -X 'GET' http://${IP}/rest-api/settings/channel/1/dsp/eqenable

{
  "value": true
}

Multizone Example

Example for controlling EQ across multiple zones (channels 1, 2, 3, 11, 12, 13):

• Enable EQ for All Zones
• JSON Payload

curl -X 'PUT' http://${IP}/rest-api/settings/channel/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '[
  {
    "channel_id": 1,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  },
  {
    "channel_id": 2,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  },
  {
    "channel_id": 3,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  },
  {
    "channel_id": 11,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  },
  {
    "channel_id": 12,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  },
  {
    "channel_id": 13,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  }
]'

[
  {
    "channel_id": 1,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  },
  {
    "channel_id": 2,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  },
  {
    "channel_id": 3,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  },
  {
    "channel_id": 11,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  },
  {
    "channel_id": 12,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  },
  {
    "channel_id": 13,
    "dsp": {
      "eqenable": {
        "value": true
      }
    }
  }
]

Note: When EQ is disabled, all equalizer settings (filters, gains, etc.) are bypassed, but the settings themselves are preserved. Re-enabling EQ will restore the previous equalizer configuration.

2.1.5 - Mute Control

Channel Mute Control

Mute control allows you to silence individual channels or the entire device.

Get Channel Mute State

Check if a channel is currently muted:

• GET Request
• Response Example

curl -X 'GET' http://${IP}/rest-api/settings/channel/1/dsp/mute

{
  "value": false
}

Mute a Single Channel

Mute a specific channel:

• PUT Request
• JSON Payload

curl -X 'PUT' http://${IP}/rest-api/settings/channel/1/dsp/mute \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "value": true
}'

{
  "value": true
}

Unmute a Single Channel

Unmute a specific channel:

• PUT Request
• JSON Payload

curl -X 'PUT' http://${IP}/rest-api/settings/channel/1/dsp/mute \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "value": false
}'

{
  "value": false
}

Mute Multiple Channels

Mute or unmute multiple channels in a single request:

• Mute Channels 1, 2, 3
• JSON Payload

curl -X 'PUT' http://${IP}/rest-api/settings/channel/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '[
  {
    "channel_id": 1,
    "dsp": {
      "mute": {
        "value": true
      }
    }
  },
  {
    "channel_id": 2,
    "dsp": {
      "mute": {
        "value": true
      }
    }
  },
  {
    "channel_id": 3,
    "dsp": {
      "mute": {
        "value": true
      }
    }
  }
]'

[
  {
    "channel_id": 1,
    "dsp": {
      "mute": {
        "value": true
      }
    }
  },
  {
    "channel_id": 2,
    "dsp": {
      "mute": {
        "value": true
      }
    }
  },
  {
    "channel_id": 3,
    "dsp": {
      "mute": {
        "value": true
      }
    }
  }
]

Toggle Mute for Multiple Channels

Toggle mute state for multiple channels (mute some, unmute others):

• PUT Request
• JSON Payload

curl -X 'PUT' http://${IP}/rest-api/settings/channel/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '[
  {
    "channel_id": 1,
    "dsp": {
      "mute": {
        "value": true
      }
    }
  },
  {
    "channel_id": 2,
    "dsp": {
      "mute": {
        "value": false
      }
    }
  }
]'

[
  {
    "channel_id": 1,
    "dsp": {
      "mute": {
        "value": true
      }
    }
  },
  {
    "channel_id": 2,
    "dsp": {
      "mute": {
        "value": false
      }
    }
  }
]

Device Mute Control

Control the main device mute that affects all channels:

Get Device Mute State

• GET Request
• Response Example

curl -X 'GET' http://${IP}/rest-api/settings/device/dsp/mute

{
  "value": false
}

Set Device Mute

• Mute Device
• Unmute Device

curl -X 'PUT' http://${IP}/rest-api/settings/device/dsp/mute \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "value": true
}'

curl -X 'PUT' http://${IP}/rest-api/settings/device/dsp/mute \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "value": false
}'

Note: Device mute acts as a master mute control. When device mute is enabled, all channels are muted regardless of individual channel mute settings.

2.1.6 - Volume Control

Channel Volume Control

Volume control is one of the most common operations. You can control individual channels or multiple channels at once.

Get Channel Volume

Retrieve the current volume setting for a specific channel:

• GET Request
• Response Example

curl -X 'GET' http://${IP}/rest-api/settings/channel/1/dsp/volume

{
  "value": -10.5
}

Set Single Channel Volume

Set the volume for a single channel. Volume range is -72.0 dB to +24.0 dB:

• PUT Request
• JSON Payload

curl -X 'PUT' http://${IP}/rest-api/settings/channel/1/dsp/volume \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "value": -10.5
}'

{
  "value": -10.5
}

Set Multiple Channel Volumes

Update volumes for multiple channels in a single request. This is more efficient than individual calls:

• PUT Request
• JSON Payload

curl -X 'PUT' http://${IP}/rest-api/settings/channel/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '[
  {
    "channel_id": 1,
    "dsp": {
      "volume": {
        "value": -10.5
      }
    }
  },
  {
    "channel_id": 2,
    "dsp": {
      "volume": {
        "value": -12.0
      }
    }
  },
  {
    "channel_id": 3,
    "dsp": {
      "volume": {
        "value": -8.5
      }
    }
  }
]'

[
  {
    "channel_id": 1,
    "dsp": {
      "volume": {
        "value": -10.5
      }
    }
  },
  {
    "channel_id": 2,
    "dsp": {
      "volume": {
        "value": -12.0
      }
    }
  },
  {
    "channel_id": 3,
    "dsp": {
      "volume": {
        "value": -8.5
      }
    }
  }
]

Get Volume Parameter Range

Check the valid volume range and step size for a channel:

• OPTIONS Request
• Response Example

curl -X 'OPTIONS' http://${IP}/rest-api/settings/channel/1/dsp/volume

{
  "value": [-72.0, 24.0, 0.1, "dB"]
}

The response format is [MIN, MAX, STEP, UNIT]:

• MIN: -72.0 dB (minimum volume)
• MAX: 24.0 dB (maximum volume)
• STEP: 0.1 dB (volume adjustment step)
• UNIT: “dB” (decibels)

Device Volume Control

Control the main device volume that affects all channels:

Get Device Volume

• GET Request
• Response Example

curl -X 'GET' http://${IP}/rest-api/settings/device/dsp/volume

{
  "value": 0.0
}

Set Device Volume

• PUT Request
• JSON Payload

curl -X 'PUT' http://${IP}/rest-api/settings/device/dsp/volume \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "value": -5.0
}'

{
  "value": -5.0
}

Note: Device volume acts as a master volume control affecting all channels. Individual channel volumes are relative to this device volume setting.

2.1.7 - AES67 / SDP subscribe

Subscribe an amplifier channel DSP patch to an external AES67 / SDP audio source. This is the same path Maxx Control’s channel-input UI uses when you paste SDP or pick a discovered AES67 flow.

When to use

Use this when a third-party sender (PipeWire, another AES67 device, etc.) publishes an SDP session and you want a MAXX channel to receive that multicast/unicast RTP stream as its input source AES67 STREAM (source_id 25).

Do not confuse this with:

Dante AES67 enable is a separate device setting (Brooklyn AES67 mode). AES67 STREAM patches use the channel patch API below.

Prerequisites

• Amplifier reachable at http://${IP}/rest-api/… (see REST API overview).

• Firmware that exposes AES67 STREAM as an input source. Confirm with:

  curl -X OPTIONS "http://${IP}/rest-api/settings/channel/1/dsp/patch"
  

  Look for source_id: 25 / "AES67 STREAM" in the source list.

• A complete SDP the device can parse (see SDP requirements below).

• Write calls need the API key header token (default documented in the overview).

API path and method

There is no PUT on /settings/channel/{channel_id}/dsp/patch/{patch_id} — only GET for a single patch. Writes always go to the collection path with one or more objects in the array.

Payload fields (AES67 STREAM)

Rules from firmware / OpenAPI:

• Put sdp_text on the patch object root. Nested rtp_flow.sdp_text is rejected.
• Do not send sdp_text and structured rtp_flow params together.
• Prefer one approach: paste SDP or fill rtp_flow.

SDP requirements

Server-side parse (same as Maxx Control paste) requires a parseable AES67 SDP with:

• PCM encoding L16 or L24 (encoding 16 or 24)
• o= session id and origin IPv4 (source address)
• a=mediaclk:direct=… (or equivalent) so clock offset is present

OpenAPI maxLength for sdp_text is 512 characters. Trim optional SDP lines if you hit the limit.

Step-by-step: PUT with sdp_text

1. Choose amp channel (channel_id) and patch (patch_id, often 1).
2. Choose stream slot (channel: 1 = first channel in the SDP, 2 = second, …).
3. PUT an array with one AES67 patch object including sdp_text.
4. GET the patch back — expect source_id 25 and populated rtp_flow (not sdp_text).
5. Optionally check patch status and persist with /settings/save.

Example SDP

v=0
o=root 1 3991817848 IN IP4 172.149.4.123
s=stream1
c=IN IP4 239.192.150.1/32
t=3991817848 0
m=audio 5004 RTP/AVP 127
i=2 channels: L, R
a=recvonly
a=rtpmap:127 L24/48000/2
a=source-filter: incl IN IP4 239.192.150.1 172.149.4.123
a=ssrc:2393712005
a=ptime:1.000000
a=framecount:48
a=ts-refclk:ptp=IEEE1588-2008:00-1D-C1-FF-FE-29-1C-8A:0
a=mediaclk:direct=2626298912
a=tool:PipeWire 1.6.7
a=type:broadcast

This session is 2 channels at 48 kHz / L24. Use "channel": 1 for L and "channel": 2 for R on two amp channels (or two patches) if needed.

JSON shape

[
  {
    "patch_id": 1,
    "source_id": 25,
    "channel": 1,
    "gain": 0.0,
    "sdp_text": "v=0\no=root 1 3991817848 IN IP4 172.149.4.123\ns=stream1\n…"
  }
]

Newlines in SDP must be encoded inside the JSON string (\n). Do not put raw multi-line SDP inside a single-quoted -d '…' shell string unless you build JSON with a tool.

curl (recommended: build JSON with Python)

export IP=10.77.150.42
export TOKEN=f4005bf8507999192162d989d5a60823

BODY=$(python3 - <<'PY'
import json
sdp = """v=0
o=root 1 3991817848 IN IP4 172.149.4.123
s=stream1
c=IN IP4 239.192.150.1/32
t=3991817848 0
m=audio 5004 RTP/AVP 127
i=2 channels: L, R
a=recvonly
a=rtpmap:127 L24/48000/2
a=source-filter: incl IN IP4 239.192.150.1 172.149.4.123
a=ssrc:2393712005
a=ptime:1.000000
a=framecount:48
a=ts-refclk:ptp=IEEE1588-2008:00-1D-C1-FF-FE-29-1C-8A:0
a=mediaclk:direct=2626298912
a=tool:PipeWire 1.6.7
a=type:broadcast"""
print(json.dumps([{
    "patch_id": 1,
    "source_id": 25,
    "channel": 1,
    "gain": 0.0,
    "sdp_text": sdp,
}]))
PY
)

curl -X PUT "http://${IP}/rest-api/settings/channel/1/dsp/patch" \
  -H "token: ${TOKEN}" \
  -H "Content-Type: application/json" \
  -d "${BODY}"

curl (inline \n escapes)

curl -X PUT "http://${IP}/rest-api/settings/channel/1/dsp/patch" \
  -H "token: ${TOKEN}" \
  -H "Content-Type: application/json" \
  -d '[{"patch_id":1,"source_id":25,"channel":1,"gain":0.0,"sdp_text":"v=0\no=root 1 3991817848 IN IP4 172.149.4.123\ns=stream1\nc=IN IP4 239.192.150.1/32\nt=3991817848 0\nm=audio 5004 RTP/AVP 127\ni=2 channels: L, R\na=recvonly\na=rtpmap:127 L24/48000/2\na=source-filter: incl IN IP4 239.192.150.1 172.149.4.123\na=ssrc:2393712005\na=ptime:1.000000\na=framecount:48\na=ts-refclk:ptp=IEEE1588-2008:00-1D-C1-FF-FE-29-1C-8A:0\na=mediaclk:direct=2626298912\na=tool:PipeWire 1.6.7\na=type:broadcast"}]'

Structured rtp_flow alternative

If you already know the RTP parameters (or you copied them from a GET after an SDP PUT):

curl -X PUT "http://${IP}/rest-api/settings/channel/1/dsp/patch" \
  -H "token: ${TOKEN}" \
  -H "Content-Type: application/json" \
  -d '[{
    "patch_id": 1,
    "source_id": 25,
    "channel": 1,
    "gain": 0.0,
    "rtp_flow": {
      "connection_ip": "239.192.150.1",
      "rtp_port": 5004,
      "sample_rate": 48000,
      "encoding": 24,
      "channels": 2,
      "session_name": "stream1",
      "clock_offset": 2626298912,
      "session_id": "3991817848",
      "source_address": "172.149.4.123"
    }
  }]'

Exact field meaning matches OpenAPI schema SettingsPatch / rtp_flow.

Verify

# Settings: parsed flow (sdp_text is write-only — not echoed)
curl "http://${IP}/rest-api/settings/channel/1/dsp/patch/1"

# Patch health
curl "http://${IP}/rest-api/status/channel/1/dsp/patch/1"

# Optional: SAP-discovered sessions (cache; may include sdp_text)
curl "http://${IP}/rest-api/info/aes67"

# Optional: Dante interface flows (interface_id from GET /status/interface/interfaces)
curl "http://${IP}/rest-api/status/interface/interfaces/4"

Persist runtime settings if needed:

curl -X PUT "http://${IP}/rest-api/settings/save" \
  -H "token: ${TOKEN}"

Related discovery endpoints

Source of truth

Path lists and schemas follow the on-device OpenAPI (Maxx Control → OVERVIEW → REST API DOC). Firmware versions can add fields; always confirm SettingsPatch on the live device. See also the REST API overview and input patch recipes.

2.1.8 - Maxx Control REST: Switch input patches

Use the Maxx Control REST API to switch channel input patches (for example Dante slots) with a bulk PUT or per-channel calls. When switching between inputs, there are multiple approaches:

• Changing the Input Patch itself
  • Patching Channels Individually
• Toggle Mute between channels
  • Toggling Mute on Individual Channels

Changing the Input Patch itself

Example Configuration for CH1, CH2, CH4, CH7, switch between Dante Input 1-4 and Dante Input 21-24

HTTP Put a full json object containing all affected Channels into the http://${IP}/rest-api/settings/channel/ path

Advantage: Using the bulk endpoint /settings/channel/ allows you to patch multiple channels in a single HTTP call, which is more efficient than making individual calls for each channel. This reduces network overhead and ensures all channels are updated atomically.

To determine the source_id of the desired Interfaces, perform an HTTP OPTION call to http://${IP}/rest-api/settings/channel/1/dsp/patch' to get a list of available interfaces.

• Patch Dante 1-4 to Channel 1,2,4,7:
• json

[
  {
    "channel_id": 1,
    "dsp": {
      "patch": [
        {
          "patch_id": 1,
          "source_id": 4,
          "channel": 1
        }
      ]
    }
  },
  {
    "channel_id": 2,
    "dsp": {
      "patch": [
        {
          "patch_id": 1,
          "source_id": 4,
          "channel": 2
        }
      ]
    }
  },
  {
    "channel_id": 4,
    "dsp": {
      "patch": [
        {
          "patch_id": 1,
          "source_id": 4,
          "channel": 3
        }
      ]
    }
  },
  {
    "channel_id": 7,
    "dsp": {
      "patch": [
        {
          "patch_id": 1,
          "source_id": 4,
          "channel": 4
        }
      ]
    }
  }
]

• Patch Dante 21-24 to Channel 1,2,4,7:
• json

[
  {
    "channel_id": 1,
    "dsp": {
      "patch": [
        {
          "patch_id": 1,
          "source_id": 4,
          "channel": 21,
          "gain": 0.0,
          "mute": false
        }
      ]
    }
  },
  {
    "channel_id": 2,
    "dsp": {
      "patch": [
        {
          "patch_id": 1,
          "source_id": 4,
          "channel": 22,
          "gain": 0.0,
          "mute": false
        }
      ]
    }
  },
  {
    "channel_id": 4,
    "dsp": {
      "patch": [
        {
          "patch_id": 1,
          "source_id": 4,
          "channel": 23,
          "gain": 0.0,
          "mute": false
        }
      ]
    }
  },
  {
    "channel_id": 7,
    "dsp": {
      "patch": [
        {
          "patch_id": 1,
          "source_id": 4,
          "channel": 24,
          "gain": 0.0,
          "mute": false
        }
      ]
    }
  }
]

Patching Channels Individually

Alternatively, you can patch each channel individually by making separate HTTP PUT calls to each channel’s endpoint: http://${IP}/rest-api/settings/channel/{channel_id}/

This approach allows you to update channels one at a time, which can be useful when you need to patch channels conditionally or handle errors per channel.

• Patch Dante 1-4 to Channel 1,2,4,7 (Individual Calls):
• Channel 1
• Channel 2
• Channel 4
• Channel 7

curl -X 'PUT' http://${IP}/rest-api/settings/channel/1/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "channel_id": 1,
  "dsp": {
    "patch": [
      {
        "patch_id": 1,
        "source_id": 4,
        "channel": 1
      }
    ]
  }
}'

curl -X 'PUT' http://${IP}/rest-api/settings/channel/2/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "channel_id": 2,
  "dsp": {
    "patch": [
      {
        "patch_id": 1,
        "source_id": 4,
        "channel": 2
      }
    ]
  }
}'

curl -X 'PUT' http://${IP}/rest-api/settings/channel/4/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "channel_id": 4,
  "dsp": {
    "patch": [
      {
        "patch_id": 1,
        "source_id": 4,
        "channel": 3
      }
    ]
  }
}'

curl -X 'PUT' http://${IP}/rest-api/settings/channel/7/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "channel_id": 7,
  "dsp": {
    "patch": [
      {
        "patch_id": 1,
        "source_id": 4,
        "channel": 4
      }
    ]
  }
}'

• Patch Dante 21-24 to Channel 1,2,4,7 (Individual Calls):
• Channel 1
• Channel 2
• Channel 4
• Channel 7

curl -X 'PUT' http://${IP}/rest-api/settings/channel/1/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "channel_id": 1,
  "dsp": {
    "patch": [
      {
        "patch_id": 1,
        "source_id": 4,
        "channel": 21,
        "gain": 0.0,
        "mute": false
      }
    ]
  }
}'

curl -X 'PUT' http://${IP}/rest-api/settings/channel/2/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "channel_id": 2,
  "dsp": {
    "patch": [
      {
        "patch_id": 1,
        "source_id": 4,
        "channel": 22,
        "gain": 0.0,
        "mute": false
      }
    ]
  }
}'

curl -X 'PUT' http://${IP}/rest-api/settings/channel/4/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "channel_id": 4,
  "dsp": {
    "patch": [
      {
        "patch_id": 1,
        "source_id": 4,
        "channel": 23,
        "gain": 0.0,
        "mute": false
      }
    ]
  }
}'

curl -X 'PUT' http://${IP}/rest-api/settings/channel/7/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "channel_id": 7,
  "dsp": {
    "patch": [
      {
        "patch_id": 1,
        "source_id": 4,
        "channel": 24,
        "gain": 0.0,
        "mute": false
      }
    ]
  }
}'

Toggle Mute between channels

Assuming we’ve already patched our desired Inputs for each channel on Slot 1 and 2

When inputs are already patched, you can toggle the mute state between different patch slots (e.g., Slot 1 and Slot 2) by only updating the mute flag in the patch object. This is more efficient than repatching the entire input configuration.

HTTP Put a JSON object containing all affected Channels into the http://${IP}/rest-api/settings/channel/ path, specifying only the patch_id and mute flag for each patch slot.

• Mute Slot 1, Unmute Slot 2 (Channels 1,2,4,7):
• json

[
  {
    "channel_id": 1,
    "dsp": {
      "patch": [
        {
          "patch_id": 1,
          "mute": true
        },
        {
          "patch_id": 2,
          "mute": false
        }
      ]
    }
  },
  {
    "channel_id": 2,
    "dsp": {
      "patch": [
        {
          "patch_id": 1,
          "mute": true
        },
        {
          "patch_id": 2,
          "mute": false
        }
      ]
    }
  },
  {
    "channel_id": 4,
    "dsp": {
      "patch": [
        {
          "patch_id": 1,
          "mute": true
        },
        {
          "patch_id": 2,
          "mute": false
        }
      ]
    }
  },
  {
    "channel_id": 7,
    "dsp": {
      "patch": [
        {
          "patch_id": 1,
          "mute": true
        },
        {
          "patch_id": 2,
          "mute": false
        }
      ]
    }
  }
]

• Mute Slot 2, Unmute Slot 1 (Channels 1,2,4,7):
• json

[
  {
    "channel_id": 1,
    "dsp": {
      "patch": [
        {
          "patch_id": 1,
          "mute": false
        },
        {
          "patch_id": 2,
          "mute": true
        }
      ]
    }
  },
  {
    "channel_id": 2,
    "dsp": {
      "patch": [
        {
          "patch_id": 1,
          "mute": false
        },
        {
          "patch_id": 2,
          "mute": true
        }
      ]
    }
  },
  {
    "channel_id": 4,
    "dsp": {
      "patch": [
        {
          "patch_id": 1,
          "mute": false
        },
        {
          "patch_id": 2,
          "mute": true
        }
      ]
    }
  },
  {
    "channel_id": 7,
    "dsp": {
      "patch": [
        {
          "patch_id": 1,
          "mute": false
        },
        {
          "patch_id": 2,
          "mute": true
        }
      ]
    }
  }
]

Toggling Mute on Individual Channels

You can also toggle mute on individual channels by making separate HTTP PUT calls to each channel’s endpoint: http://${IP}/rest-api/settings/channel/{channel_id}/

• Mute Slot 1, Unmute Slot 2 (Individual Calls):
• Channel 1
• Channel 2
• Channel 4
• Channel 7

curl -X 'PUT' http://${IP}/rest-api/settings/channel/1/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "channel_id": 1,
  "dsp": {
    "patch": [
      {
        "patch_id": 1,
        "mute": true
      },
      {
        "patch_id": 2,
        "mute": false
      }
    ]
  }
}'

curl -X 'PUT' http://${IP}/rest-api/settings/channel/2/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "channel_id": 2,
  "dsp": {
    "patch": [
      {
        "patch_id": 1,
        "mute": true
      },
      {
        "patch_id": 2,
        "mute": false
      }
    ]
  }
}'

curl -X 'PUT' http://${IP}/rest-api/settings/channel/4/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "channel_id": 4,
  "dsp": {
    "patch": [
      {
        "patch_id": 1,
        "mute": true
      },
      {
        "patch_id": 2,
        "mute": false
      }
    ]
  }
}'

curl -X 'PUT' http://${IP}/rest-api/settings/channel/7/ \
-H 'Content-Type: application/json' \
-H 'token: f4005bf8507999192162d989d5a60823' \
-d '{
  "channel_id": 7,
  "dsp": {
    "patch": [
      {
        "patch_id": 1,
        "mute": true
      },
      {
        "patch_id": 2,
        "mute": false
      }
    ]
  }
}'

2.1.9 - Amp enable

Power-enable a channel amplifier stage (distinct from mute):

PUT /settings/channel/{channel_id}/ampenable

curl -X PUT "http://${IP}/rest-api/settings/channel/1/ampenable" \
  -H "token: f4005bf8507999192162d989d5a60823" \
  -H "Content-Type: application/json" \
  -d '{"value": true}'

Use "value": false to disable. Multi-channel updates can go through PUT /settings/channel with ampenable on each object.

2.1.10 - Save / persist

Runtime changes are held until they are saved. Trigger a manual save with:

PUT /settings/save (token required; no JSON body)

curl -X PUT "http://${IP}/rest-api/settings/save" \
  -H "token: f4005bf8507999192162d989d5a60823"

Check save / autosave state with GET /status/save.

2.2 - Third Party Plugins

These plugins use the device REST API to control one amplifier each. For multi-amp project control, use Maxx Remote instead.

2.2.1 - Loxone Maxx Control plugin

Loxone integrators can control one Innosonix amplifier via Maxx Control using the Loxone Library plugins and example templates. Install the add-ons into Loxone Config, point each instance at the amp IP (or hostname.local), and drive mute, volume, and status over the device REST API.

What is the Loxone Maxx Control plugin?

The Loxone Maxx Control integration is a set of .LxAddon plugins from the Loxone Library that talk to a single amplifier’s Maxx Control REST API. Instantiate a plugin once per physical device.

Which Loxone templates do I need?

Because Loxone can only combine either Virtual Inputs or Virtual Outputs in a template file, two different templates have to be installed:

• MAXX-CONTROL which allows to set parameters to the amplifier
• MAXX-STATUS fetches Data from the Amplifier, mainly intended for Channel and Device Status

It’s totally valid to use only one, depending on your needs.

Installation

Download the corresponding .LxAddon Files and install it into your Loxone Config by double clicking or via the Import wizard like:

General

Both Plugins can be instantiated multiple times, as often as you want to control physical devices.

MAXX-CONTROL

Download the MAXX-CONTROL.Loxone example file from the Loxone Library

The Template basically provides the following predefined controls:

• Channel Power
• Channel Mute
• Channel Volume
• Device Identify
• Device Master Mute
• Device Master Volume

and some examples of how to create custom commands for improved performance.

Power / Mute

Simple digital outputs which can be grouped together in any desired combination.

Volume

Similar to Power / Mute Volume will send out any changes for each output as a single http request.

The interesting part here is how to map the common Loxone Analog Values in a range of 0-10 to a dB value for the amplifiers. That can be easily done with the Correction field of each output. The default configuration will map the values of 0-10 to -72dB - +10dB

This will give you almost the full dynamic range of the volume value:

Combined Commands

A basic understanding of the REST-API interface is recommended to create those combined commands.

As a starting point, have a look at the three included examples:

• Multichannel Mute
• Multichannel Power
• Multichannel Volume

Those commands send the same value to multiple channels within a single HTTP request, significantly improving performance when many channels are involved in a call.

Multichannel Mute

Let’s have a look at the HTTP body which is sent out when the DIGITAL OUTPUT is set to ON by clicking on the edit button of that line:

You basically see a JSON payload file containing an ARRAY of single JSON objects for the corresponding channels, indicated by the channel_id tag:

[
  {
    "channel_id": 1,
    "dsp": {
      "mute": {
        "value": true
      }
    }
  },
  {
    "channel_id": 5,
    "dsp": {
      "mute": {
        "value": true
      }
    }
  },
  {
    "channel_id": 7,
    "dsp": {
      "mute": {
        "value": true
      }
    }
  },
  {
    "channel_id": 30,
    "dsp": {
      "mute": {
        "value": true
      }
    }
  }
]

To modify that, simply duplicate the entries:

{
   "channel_id": 1,
   "dsp": {
      "mute": {
         "value": true
      }
   }
},

for each channel, you want to control and change the channel_id to the desired channel number.

MAXX-STATUS

Download the MAXX-STATUS.Loxone example file from the Loxone Library

The MAXX-STATUS Template periodically polls the /rest-api/status URL of the amplifier and filters the response for each channel status/device status.

The raw CHxx STATUS value represents the default syslog severity levels like:

In combination with the provided STATUS component with the following settings:

An easy virtualization can be achieved.

Combining the Val output of each STATUS component with an OR Gate, a simple GLOBAL STATUS can be generated when any channels or device assert any state higher than NOTICE ( see STATUS settings, State value).

2.2.2 - Q-SYS Maxx Control plugin

Q-SYS integrators can control one Innosonix amplifier via Maxx Control using the Innosonix Maxx Control plug-in for Q-SYS Designer. Add the plug-in to your design, enter the amp IP, and expose mute, volume, meters, and status to Q-SYS UCIs and logic.

What is the Q-SYS Maxx Control plugin?

Innosonix provides a plug-in that integrates Maxx Series amplifiers (Maxx Control) with the QSC Q-SYS ecosystem. Devices can then be controlled from Q-SYS Designer, Q-SYS compatible user-control interfaces, and GPIO logic on Q-SYS cores and peripherals.

You must be using Q-SYS Designer 9.8 or above.

Control features

• Ampenable
• Ch Fault
• Ch Name
• Ch Status
• Connection Status
• Device Fault
• Device Status
• Disable
• Input Meter Level
• IP Address
• Load Monitor Impedance
• Mute
• Output Meter Level
• Output Meter Reduction
• Volume

Innosonix devices must have firmware version V3.19.4 or above installed to be compatible with the Maxx Control Plug-in. If you are unsure what firmware you device is currently using, please download IDFM to help confirm and if need be install up to date firmware.

For further control and processing capabilties of your Maxx Device please download Maxx Remote

How do I install it in Q-SYS Designer?

1. Download the Innosonix Maxx Control Plug-in from the Third Party Downloads section of the Downloads section of our website.

2. Copy the downloaded plug-in file into the My Documents/QSC/Q-Sys Designer/Plugins folder (exact filename is in the download package from the Innosonix website).

3. Open Q-SYS Designer; the plug-in appears under Schematic Elements → Plugins:

   

4. Drag and drop the Plug-in into your design and select it by clicking once on the Plug-in icon.

5. Control pins can be enabled by ticking the check-boxes in the “Control Pins” section as required:

   

6. Go “Online” with your Q-Sys project. If devices are not connected you can use the “Emulate” function under the “File” tab in the menu above.

7. Double-click the plug-in icon, open the Global tab, and enter the amplifier IP address. The IP is shown on the device front panel, or use IDFM to discover it:

   

8. The “Global Tab” notifies the user of important information on the Innosonix device including:

   • IP Address
   • Model
   • Software Version
   • Serial Number
   • Device Name
   • Device Location
   • Pole Counter
   • Device Status

9. Select the “Channels Tab”:

   

10. Within the “Channels Tab” the user has the facility to adjust a number of the devices features including:

• Mute
• Enable or Disable Channel
• Volume

Further Assistance:

For any more information please visit feel free to Contact us!

3 - Maxx Remote

Maxx Remote is the project-based control software for Innosonix amplifiers. You design the system as channels (speakers) and groups (rooms or zones), then link those to real amplifier outputs when the hardware is available. micro MAXX amplifiers have full Maxx Remote support alongside other MAXX models.

What / when / how: use Maxx Remote when one site has many amplifiers or you need room-level groups, offline projects, or undo/redo while tuning. Install the Desktop app or Docker server, create a project, add channels and groups, link devices, then operate from GROUPS / CHANNELS / VIEW.

Use Maxx Remote when you need:

• One place to tune and operate many amplifiers
• Groups for room-level volume, mute, EQ, and routing
• Offline planning before the amps are on site
• Undo / redo while dialing in a system
• Operator-friendly VIEW pages for day-to-day control

Desktop vs Server

Both forms run the same Maxx Remote server and web UI. The Desktop app includes the server; Docker exposes the same UI on port 8000.

Maxx Remote vs Maxx Control

See the full comparison table on the Software overview.

Recommended reading path

1. Concept — channels, groups, devices, and how values add up
2. Installation — Desktop or Docker
3. Prerequisites — network, discovery, Dante, ports
4. Quick-Start — L / R / Sub demo with music
5. Projects — create, save, export, persist on Docker
6. Build a system — channels, linking, inputs, tuning
7. Everyday control — operate rooms and VIEW pages
8. Advanced — multi-way speakers, surround, speaker presets
9. Troubleshoot — sync, discovery, Dante, device replace
10. GUI reference and API when you need screen-level or integration detail

3.1 - Concept

Goal / when to use

Read this once before you build a project. Maxx Remote sits between your speakers / rooms and the amplifier hardware, so you can tune and operate without constantly asking “which amp, which output?”

Mental model

Maxx Remote is an abstraction layer over amplifier outputs. It does not matter whether 1,000 speakers sit on thirty-two 32-channel amplifiers or on many smaller units — you work with project channels and groups.

As an operator or tuner, you usually care about this speaker or this room, not which physical output is used that day. Linking can change later; the channel settings stay in the project.

System overview

Desktop / Server and UI

Maxx Remote always consists of:

1. A server that holds the project and talks to amplifiers
2. A web UI (the screens you use in the browser or Desktop window)

Access the UI at http://localhost:8000 on the machine running the server (or http://<server-ip>:8000 for Docker / remote hosts).

Objects you will use

How they relate

A channel behaves like a channel strip: you can set it directly.

If that channel also belongs to one or more groups, group values are added (summed) with the channel’s own values. The result is what the amplifier should play.

Example for volume:

When a channel is linked to a HW channel, Maxx Remote sends that output result to the device.

Because settings live in the Maxx Remote project, you can replace an amplifier or re-link speakers to different outputs without rebuilding the whole tuning from scratch.

Out of Sync

After a channel is linked, Maxx Remote periodically compares project data with the device. Someone can still change the amp from Maxx Control or other tools — Maxx Remote then reports OUT OF SYNC for the mismatched parameters.

You resolve sync by aligning values in Maxx Remote with the device, or by pushing project data to the device (SYNC). Details: Troubleshoot.

Expected result

You understand that:

• Channels and groups are how you design and operate the system
• Devices and HW channels are how sound reaches the speakers
• Output levels are the sum of channel + group contributions

Common mistakes

Related links

• Installation
• Quick-Start
• Channels and groups
• Devices and linking

3.2 - Installation

Goal / when to use

Get Maxx Remote running so you can open the UI and create or load a project.

• Choose Desktop for commissioning laptops and day-to-day design work.
• Choose Docker for an always-on server that browsers can reach on the network.

Prerequisites

• Supported OS for Desktop, or a host that can run Docker
• Network access to your amplifiers (see Prerequisites)
• For automatic discovery (amplifiers and Dante TX sources): the host must receive the UDP broadcast / multicast traffic listed under Ports and discovery — on Docker that means host networking

Desktop application

1. Download Maxx Remote from the Innosonix downloads page.
2. Unpack or place the portable application where you want it — no installer is required.
3. Start the application.
4. On first launch, use Start a new project or import an existing project archive.

Expected result

The Maxx Remote window opens with the project splash / HOME UI. You can also reach the same UI in a browser at http://localhost:8000 while the Desktop app is running.

Server / Docker

Ports and discovery

Maxx Remote listens for more than the web UI. Automatic discovery uses UDP broadcast and multicast, which Docker’s default bridge network does not forward reliably when you only publish ports with -p.

Maxx Remote also sends outbound unicast UDP to Dante devices (ARC channel queries, typically ports 4440 / 4444 / 4455, and CMC registration, typically 8800). Those are device-side ports — they are not something you “publish” on the container; the host firewall must allow the outbound path.

Recommended: host network (discovery works)

Use host networking whenever you want automatic amplifier scan or Dante TX discovery:

docker run --detach --name maxx-remote --network host innosonix/maxx-remote:latest

Once the container is running, open:

http://<docker-host-ip>:8000

Alternative: published ports (UI only — no discovery)

If you only need the web UI and will add amplifiers by IP / hostname (and do not rely on Maxx Remote’s Dante discovery), bridge networking with a published HTTP port is fine:

docker run --detach \
  --name maxx-remote \
  -p 8000:8000 \
  innosonix/maxx-remote:latest

Compose equivalent:

services:
  maxx-remote:
    image: innosonix/maxx-remote:latest
    ports:
      - "8000:8000"
    # Discovery (INX + Dante) will not work reliably on the default bridge.
    # Prefer network_mode: host when you need ADD FROM NETWORK or Dante TX scan.

Do not expect a long -p 9453:9453/udp -p 5353:5353/udp … list to replace --network host for discovery. Map TCP 8000 for the UI; use host networking when discovery matters.

Persist project data (recommended)

Option A — Export / import yourself

Use the UI Export / Import controls when you migrate to a new container.

Option B — Docker volume (preferred)

# create once
docker volume create maxx-remote-volume

docker run  --detach \
            --restart always \
            --name maxx-remote \
            --network host \
            --mount source=maxx-remote-volume,target=/root \
            innosonix/maxx-remote:latest

Expected result

Browsers on the network can open the Maxx Remote UI on port 8000, and projects survive container restarts when a volume is mounted. With --network host, ADD FROM NETWORK and Dante TX discovery can see devices on the same LAN segment.

Common mistakes

Related links

• Prerequisites
• Quick-Start
• Projects
• Docker Hub: innosonix/maxx-remote

3.3 - Prerequisites

Goal / when to use

Check this list before you expect amplifiers to appear automatically, Dante streams to route, or a Docker server to stay reachable.

1. Device network setup (IDFM)

Before Maxx Remote, put amplifiers on a working IP plan with IDFM (install):

1. Discover devices.
2. Set IP mode / address / hostname as required by the site.
3. Update firmware if IDFM reports newer versions.

2. Ports and reachability

Outbound (device-side ports Maxx Remote talks to, not listens on): Dante ARC queries typically 4440 / 4444 / 4455, CMC registration typically 8800.

Firewall / VLAN notes:

• The PC or Docker host must reach each amplifier’s management IP (HTTP/API used by Maxx Remote).
• Discovery broadcast/multicast usually do not cross routers. Across subnets, add amplifiers by hostname + IP instead of relying on scan.
• Docker: use --network host for automatic INX and Dante discovery. Publishing only -p 8000:8000 is enough for the UI if you add devices manually — see Installation.

3. Dante (audio network)

If you use Dante input sources:

• Amplifiers and sources must share a working Dante network (often separate from or VLAN’d from control).
• Maxx Remote discovers Dante TX channels on the LAN (mDNS + multicast control plane above). You can still use Dante Controller (or equivalent) to confirm Transmit Channel@Hostname names when creating INPUTS.
• Maxx Remote can create dynamic Dante subscriptions (often shown with a D: prefix in Dante Controller).
• On Docker, Dante discovery needs the same host-network path as amplifier discovery — bridge -p mappings are not enough.

Stereo / surround routing is covered in Inputs and routing and Surround input sources.

4. Control PC / server

• Desktop: portable Maxx Remote build for your OS
• Server: Docker host with enough disk for a volume (do not rely on ephemeral container storage)
• Browser: modern Chromium / Firefox / Edge for the web UI

5. Project planning (optional)

You can create channels, groups, EQ, and routing offline with no amplifiers present. Link hardware later on site. See Projects.

Expected result

• Amplifiers respond to ping / IDFM
• Maxx Remote UI opens on port 8000
• Amplifier and Dante discovery work on the same L2 segment (or you are ready to add amplifiers manually and pick TX names from Dante Controller)

Common mistakes

Related links

• IDFM · Install · Discover and IP
• Installation
• Quick-Start
• Troubleshoot

3.4 - Quick-Start

Goal / when to use

Get first music out of a simple system: three speakers (Left, Right, Sub) on an MA32/D², with group volume/EQ and a stereo Dante source (for example Dante Virtual Soundcard).

This is a guided walkthrough. For deeper topics afterward, use Build a system and Everyday control.

Prerequisites

• Maxx Remote installed and running (Installation)
• Amplifier on the network (Prerequisites, IDFM / install)
• Speakers on amp channels 1, 4, and 9 (or adapt the link steps)
• Dante TX available (hostname + transmit channel names)

1. Create a project

1. Start Maxx Remote. On the splash screen, click Start a new project.
2. Enter a project name and confirm.

Expected result

HOME opens for the new project.

2. Create channels and a group

1. Open CHANNELS → MAP | CREATE.

   

2. Click + CHANNEL, set CHANNELS TO ADD to 3, name them (for example Left, Right, Subwoofer), then CREATE CHANNELS.

   

3. Confirm the three PROJECT CHANNELS exist. LINKED TO is empty until you connect hardware.

   

4. Click + GROUP, name it (for example ROOM 1), and create it.

   

5. Map all three channels into the group: drag and drop, or select them and click MAP.

   

Expected result

Three unlinked channels mapped to ROOM 1.

3. Add the amplifier and link outputs

1. Open DEVICES → ADD DEVICE.

2. Add a device found on the network, or add manually (model + hostname).

3. Disable CREATE CHANNELS / GENERATE PROJECT CHANNELS if offered — you already created the three you need.

   

4. Wait until Maxx Remote connects. Use CONNECT to disable network activity if needed.

   

5. Open the LINK CHs (linked channels) control.

   

6. Use IDENTIFY to play a test tone (for example pink noise at −40 dB) and confirm the physical speaker.

   

7. Link each project channel to the correct HW channel (drag and drop or LINK).

   

8. Finish Left, Right, and Sub.

   

9. Reorder later by dragging HW channels between empty slots, or swap by dropping onto an assigned slot.

Expected result

All three project channels show a hardware link; identify confirms the correct speakers.

4. Set safe group volume

1. Open GROUPS and click the VOLUME field for ROOM 1.

   

2. Enter -20 and press Enter or SET.

   

3. On CHANNELS, raise the Subwoofer channel by +6 dB for a bit of boost.

Example: group −20 dB + channel +6 dB → −14 dB output.

Expected result

Room is at a safe level; Sub sits 6 dB hotter than Left/Right at the channel layer.

5. EQ the Subwoofer

1. Open CHANNELS → EQ for Subwoofer.

2. Drag a LOW PASS filter into the EQ view.

   

3. Select the filter (blue handle / row), open the gear editor, pick for example 24 dB Butterworth, confirm OK.

   

4. Set frequency by dragging or typing, then Enter / SET.

5. Add more filters if needed.

   

6. EQ the group (room)

1. Add overall EQ on GROUPS → ROOM 1.

   

2. Jump back to the group’s channels (arrow control).

   

3. Re-open Subwoofer EQ — you should see channel EQ plus group EQ summed.

   

Expected result

Room EQ affects all members; Sub still shows its own low-pass on top.

7. Create Dante INPUTS and assign roles

From Dante Controller, note Transmit Channel@Hostname (example: 01@STEFFEN-PC).

1. Open INPUTS → + INPUT SOURCE. Fill in:

   • SOURCE LABEL — name in Maxx Remote
   • RECEIVE HOSTNAME — Dante device hostname
   • RECEIVE LABEL — transmit channel name

   

2. Open GROUPS → INPUT and assign the source to ROOM 1.

   

3. Channels inherit the source using their ROLE (Left / Right / Mono, …).

4. If Left is still MONO, it may downmix both legs — set ROLE → LEFT.

   

   

   

5. Confirm Dante Controller shows dynamic subscriptions (often prefixed with D:).

   

6. Set Right to role RIGHT. Leave Sub as MONO for a stereo downmix to the sub.

Expected result

Music plays Left / Right / Sub with correct legs; Dante shows the subscriptions Maxx Remote created.

Checklist — you are done when

• Project created and named
• Three channels + one group, channels mapped to the group
• Amplifier connected; three HW links confirmed with IDENTIFY
• Group volume set to a safe level; Sub offset applied if desired
• Sub low-pass (and optional room EQ) in place
• Stereo INPUT created and assigned to the group
• Channel roles Left / Right / Mono correct
• Audio heard on all three speakers

Common mistakes

Related links

• Projects
• Build a system
• Surround input sources
• Troubleshoot

3.5 - Projects

Goal / when to use

Manage the project file that holds your channels, groups, devices, inputs, views, and tuning. Use this when starting a job, moving between machines, or keeping a Docker server’s configuration safe.

Prerequisites

• Maxx Remote Desktop or Server running (Installation)

Create a new project

Desktop or browser splash

1. Start Maxx Remote with no project loaded.
2. Choose Start a new project.
3. Enter a clear site name (for example Museum-Floor2).

Desktop menu (Electron)

Use the application menu when available:

• New Project
• Load Project / Last Projects
• Save Project / Save Project As
• Close Project

Expected result

HOME shows the new project name; DEVICE / CHANNEL counts start empty.

Open / import an existing project

1. On the splash screen, choose Import project archive to host, or
2. Use the top-bar Import control to upload a project archive or partial JSON.

Expected result

HOME and list pages populate with the imported project.

Export / backup

1. Use the top-bar Export control.
2. Store the download with your site documentation.

Export before:

• Updating Maxx Remote
• Recreating a Docker container
• Handing the project to another engineer

Offline planning

You can design without amplifiers:

1. Create channels and groups.
2. Set volumes, EQ, delay, mute, speaker presets.
3. Define INPUTS and roles (even if Dante is not online yet).
4. On site, add devices and link.

Project settings stay in Maxx Remote until you link and sync to hardware.

Docker persistence

Recommended pattern:

1. Mount a volume (see Installation).
2. Periodically Export from the UI as an off-host backup.
3. When migrating hosts, import the archive into the new server.

HOME project card

On HOME you can:

• View / set the project NAME
• See overall STATUS for devices and linked channels
• Enable AUTO SYNC so Maxx Remote can push project data when differences are found
• Open REST-API Doc for integrators

Details: GUI · HOME.

Expected result

You can create, reopen, and back up a project, and you know how Docker storage differs from Desktop files.

Common mistakes

Related links

• Installation
• Quick-Start
• Troubleshoot

3.6 - Build a system

Goal / when to use