Profile Information
Admin Access
Open Admin DashboardPreview Program
Get early access to new features by joining our Preview Program.
Application Pending
Your application is being reviewed. We'll notify you by email once it's been processed.
Welcome to the Preview Program! 🎉
You have access to preview features like DJ Stats, Device Management, MIXEY AI, Leaderboard and MIXERA Connect. Check them out in the sidebar!
Application Not Accepted
Your application was not accepted at this time.
Admin Access
As an admin, you have automatic access to all preview features.
MIXERA Cloud
Enable Cloud Access for Devices
Allow your registered devices to access and download tracks from your Mixera Cloud library
When enabled, your devices can browse and download tracks from your cloud library. Each device must be registered to your account to access your music.
Badges & Leaderboard
Show on Leaderboard
Allow your stats to appear on the public leaderboard
Your Badges
Toggle which badges are visible on your profile and in leaderboards
Security Settings
Change Password
Update your password to keep your account secure.
Email Verification
Active Sessions
You're currently signed in on this device.
Your DJ Statistics
Last updated: TodayPreview Mode - Demo Data
This is a preview of upcoming features. The statistics shown are simulated demo data. Real data will be available once you connect your MIXERA controller.
MIXEY
AIClick the button below to get your personalized weekly summary from MIXEY!
Transition Analysis
Top Genres
Activity
Achievements Unlocked
Power & Climate
For every 100 kWh used, MIXERA plants a tree to offset your carbon footprint.
BPM Range
When You DJ
Most active: Saturday 11PM
Fun Facts
Session Heatmap (Last 12 Weeks)
Personal Records
Community Leaderboard
Preview Mode - Demo Data
This leaderboard uses demo data. Real rankings will be available when you connect your MIXERA controller.
Badge Legend
Rank badges use icons specific to each category (clock for playtime, arrows for transitions, star for sessions, music note for tracks, fire for streaks)
MIXERA Connect
Preview Mode - Demo Data
MIXERA Connect uses demo data. Real DJ connections will be available once the feature is fully launched.
MIXEY Matches
DJs with similar styles and stats
Your DJ Profile
Profile analyzed from your DJ Stats
Select a DJ to start chatting
Choose from your MIXEY matches
Welcome to MIXERA Connect
MIXEY has found DJs with similar styles to yours! Select someone from the matches list to start a conversation and connect with fellow DJs.
MIXEY AI Assistant
AI PoweredPreview Mode - Demo Assistant
MIXEY is currently a demo assistant. Full AI capabilities will be available when the feature launches.
Quick Questions
MIXEY
Always available
Hey there! 👋 I'm MIXEY, your personal MIXERA assistant!
I have access to your account information and can help you with:
- Understanding your badges and how to earn more
- Explaining your DJ statistics
- Device information and warranty status
- Account details and settings
Ask me anything about your MIXERA account! 🎧
Just now
GEMA License Calculator
gema.deEstimate Only - Not Official
This calculator provides rough estimates based on GEMA's public tariff information. Actual fees may vary. Always contact GEMA directly for official quotes and licensing.
Event Details
Enter 0 for free events
Estimated GEMA Fee
Tariff: -€0.00
+ VAT (7% or 19%)
This estimate is based on GEMA's general tariff structure. Special events, recurring events, or venues with existing GEMA contracts may have different rates.
MIXEY
GEMA Expert
Hi! I'm here to help you understand GEMA licensing. Ask me anything about:
- • What is GEMA?
- • Tariff categories
- • When you need a license
- • How to register
Common Tariffs
MIXERA Cloud
2 GB StoragePreview Mode - Demo Data
MIXERA Cloud is in preview. The tracks shown are demo data. Full cloud functionality will be available when the feature launches.
Upload Tracks
Drop files here or click to upload
MP3, WAV, FLAC, AIFF (max 100MB)
Sync Settings
Linked Devices
Your Tracks
| Track | BPM | Key | Genre | Size | Synced | Actions |
|---|
MIXERA Cloud
2 GB StorageUpload Tracks
Drop files here or click to upload
MP3, WAV, FLAC, AIFF (max 100MB)
If a user has MIXERA Pro they can skip the queue (mock).
Sync Settings
Linked Devices
No devices connected
MIXEY AI BETA
Let AI create the perfect playlist for your set. Just describe the vibe!
Your Tracks
| Track | BPM | Key | Genre | Duration | Status | Actions |
|---|
MIXERA Infinity
∞ UpgradesPreview Mode - Demo Data
MIXERA Infinity is in preview. Pricing and features shown are for demonstration. Actual availability and pricing may vary at launch.
Select Devices for Upgrade
Choose which devices to apply connectivity upgrades
Controller Connectivity
Your MIXERA CTRL one includes a built-in eSIM with 10 MB/month for telemetry and device security. Upgrade to unlock cloud music streaming and SoundCloud integration.
Alternative options: You can use all streaming features for free when connected to WiFi/LAN or your phone's hotspot. You can also activate your own eSIM directly on the device.
Basic
Included with your device
- 10 MB/month data
- Telemetry & Stats
- Device locking/security
- Cloud music push
- SoundCloud streaming
Starter
Perfect for occasional use
- 250 MB/month data
- All Basic features
- Cloud music push
- SoundCloud streaming
Pro
For regular performers
- 1 GB/month data
- All Starter features
- Priority data routing
- Data rollover (unused data)
Unlimited
For heavy streaming
- Unlimited data
- All Pro features
- Global roaming included
- Priority support
Use Your Own eSIM
Activate any compatible eSIM directly on your device for full flexibility
MIXERA Cloud Storage
Your account includes 2 GB of cloud storage. Upgrade for more space to store and sync your tracks.
Basic Cloud
Included with MIXERA ID
- 2 GB storage
- Track analysis
- Device sync
Cloud Plus
For growing libraries
- 25 GB storage
- All Basic features
- Version history
Cloud Pro
For professional DJs
- 100 GB storage
- All Plus features
- Priority sync
Pay As You Go
Only pay for what you use
- Flexible storage
- No monthly commitment
- Scale as needed
Connect External Storage
Link your existing Google Drive or Dropbox account for cloud storage.
Not connected
-
Note: Using external storage disables direct push to devices. You'll need to manually download tracks to your device via WiFi/USB.
MIXERA Infinity ALL-IN-ONE
The ultimate DJ experience - everything included
/month
Save €10+/month vs separate plans
- • Advanced AI track analysis
- • Intelligent cue detection
- • Harmonic mixing advisor
- • Smart setlist building
- • Unlimited mobile data
- • Global roaming (190+ countries)
- • Priority data routing
- • All devices included
- • High speed 5G (Europe)
- • 200 GB music storage
- • Unlimited version history
- • Priority sync speed
- • Automatic backup
- • Priority 24/7 support
- • Early feature access
- • Exclusive beta programs
- • Skip queses for track analysis
Or save 20% with yearly billing:
Your Current Subscription
No active paid plans
Connected Applications
Apps with access to your account
No apps have access to your account yet.
When you use "Login with Mixera ID" on other sites, they'll appear here.
Developer: Your Apps
Create OAuth clients to add "Login with Mixera ID" to your own websites and apps.
App Guidelines
To get your app approved, please ensure:
- Your app has a clear, descriptive name
- Redirect URIs use HTTPS (except localhost for testing)
- Your website URL is valid and accessible
- Your app doesn't impersonate Mixera or other brands
- Your app provides value to users and isn't spam
Apps that violate these guidelines may be denied or revoked. Contact support if you have questions.
Create OAuth Application
App Created - Pending Review
Save these credentials now - the secret won't be shown again!
Note: Your app needs to be reviewed before it can be used.
Need help testing your integration?
Open OAuth Test Page →Developer Documentation
Learn how to integrate "Login with Mixera ID" into your application.
Quick Start
- Create an OAuth app in the section
- Save your
client_idandclient_secret - Wait for your app to be approved by our team
- Implement the OAuth flow in your application
- Exchange the authorization code for user information
OAuth 2.0 Flow
Redirect to Authorization
Send the user to our authorization endpoint:
https://mixera.pro/api/oauth/authorize?client_id=YOUR_CLIENT_ID&redirect_uri=YOUR_REDIRECT_URI&response_type=code&state=RANDOM_STATE
User Authorization
The user logs in and authorizes your app. They are then redirected back to your redirect_uri with a code parameter.
Download our ready-to-use callback page template with MIXERA branding for your redirect URI:
Exchange Code for Token
Exchange the authorization code for user information:
POST https://mixera.pro/api/oauth/token
Content-Type: application/json
{
"client_id": "YOUR_CLIENT_ID",
"client_secret": "YOUR_CLIENT_SECRET",
"code": "AUTHORIZATION_CODE",
"redirect_uri": "YOUR_REDIRECT_URI",
"grant_type": "authorization_code"
}
Receive User Data
On success, you'll receive the user's information:
{
"access_token": "...",
"token_type": "Bearer",
"user": {
"mixeraId": "MXR-XXXXXXXX",
"email": "user@example.com",
"name": "User Name",
"profilePicture": "https://..."
}
}
API Endpoints
/api/oauth/authorize
Initiates the OAuth authorization flow.
Query Parameters:
| client_id | Required. Your application's client ID. |
| redirect_uri | Required. Must match a registered redirect URI. |
| response_type | Required. Must be code. |
| state | Recommended. A random string to prevent CSRF attacks. |
/api/oauth/token
Exchanges an authorization code for user information.
Request Body (JSON):
| client_id | Required. Your application's client ID. |
| client_secret | Required. Your application's client secret. |
| code | Required. The authorization code received. |
| redirect_uri | Required. Must match the original request. |
| grant_type | Required. Must be authorization_code. |
Code Examples
Add a "Login with Mixera ID" button to your website:
<!-- Login Button -->
<button onclick="loginWithMixera()" style="
background: #A259FF;
color: white;
padding: 12px 24px;
border: none;
border-radius: 8px;
font-weight: 600;
cursor: pointer;
">
Login with Mixera ID
</button>
<script>
const CLIENT_ID = 'your_client_id';
const REDIRECT_URI = 'https://yoursite.com/callback';
const API_BASE = 'https://mixera.pro';
function loginWithMixera() {
const state = Math.random().toString(36).substring(7);
sessionStorage.setItem('oauth_state', state);
const authUrl = `${API_BASE}/api/oauth/authorize?` +
`client_id=${CLIENT_ID}&` +
`redirect_uri=${encodeURIComponent(REDIRECT_URI)}&` +
`response_type=code&` +
`state=${state}`;
window.location.href = authUrl;
}
// On your callback page:
async function handleCallback() {
const params = new URLSearchParams(window.location.search);
const code = params.get('code');
const state = params.get('state');
// Verify state
if (state !== sessionStorage.getItem('oauth_state')) {
alert('Invalid state parameter');
return;
}
// Exchange code for token (do this server-side in production!)
const response = await fetch(`${API_BASE}/api/oauth/token`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
client_id: CLIENT_ID,
client_secret: 'your_client_secret', // Keep secret server-side!
code: code,
redirect_uri: REDIRECT_URI,
grant_type: 'authorization_code'
})
});
const data = await response.json();
console.log('User:', data.user);
}
</script>
Express.js server implementation:
const express = require('express');
const axios = require('axios');
const app = express();
const CLIENT_ID = process.env.MIXERA_CLIENT_ID;
const CLIENT_SECRET = process.env.MIXERA_CLIENT_SECRET;
const REDIRECT_URI = 'https://yoursite.com/auth/callback';
const API_BASE = 'https://mixera.pro';
// Route to initiate OAuth flow
app.get('/auth/mixera', (req, res) => {
const state = Math.random().toString(36).substring(7);
req.session.oauthState = state;
const authUrl = `${API_BASE}/api/oauth/authorize?` +
`client_id=${CLIENT_ID}&` +
`redirect_uri=${encodeURIComponent(REDIRECT_URI)}&` +
`response_type=code&` +
`state=${state}`;
res.redirect(authUrl);
});
// OAuth callback route
app.get('/auth/callback', async (req, res) => {
const { code, state } = req.query;
// Verify state
if (state !== req.session.oauthState) {
return res.status(400).send('Invalid state');
}
try {
// Exchange code for token
const response = await axios.post(`${API_BASE}/api/oauth/token`, {
client_id: CLIENT_ID,
client_secret: CLIENT_SECRET,
code,
redirect_uri: REDIRECT_URI,
grant_type: 'authorization_code'
});
const { user, access_token } = response.data;
// Create session or JWT for the user
req.session.user = user;
res.redirect('/dashboard');
} catch (error) {
console.error('OAuth error:', error.response?.data);
res.status(500).send('Authentication failed');
}
});
app.listen(3000);
Flask server implementation:
from flask import Flask, redirect, request, session, url_for
import requests
import secrets
import os
app = Flask(__name__)
app.secret_key = os.urandom(24)
CLIENT_ID = os.environ.get('MIXERA_CLIENT_ID')
CLIENT_SECRET = os.environ.get('MIXERA_CLIENT_SECRET')
REDIRECT_URI = 'https://yoursite.com/auth/callback'
API_BASE = 'https://mixera.pro'
@app.route('/auth/mixera')
def login():
state = secrets.token_urlsafe(16)
session['oauth_state'] = state
auth_url = (
f"{API_BASE}/api/oauth/authorize?"
f"client_id={CLIENT_ID}&"
f"redirect_uri={REDIRECT_URI}&"
f"response_type=code&"
f"state={state}"
)
return redirect(auth_url)
@app.route('/auth/callback')
def callback():
code = request.args.get('code')
state = request.args.get('state')
# Verify state
if state != session.get('oauth_state'):
return 'Invalid state', 400
# Exchange code for token
response = requests.post(
f"{API_BASE}/api/oauth/token",
json={
'client_id': CLIENT_ID,
'client_secret': CLIENT_SECRET,
'code': code,
'redirect_uri': REDIRECT_URI,
'grant_type': 'authorization_code'
}
)
if response.status_code != 200:
return 'Authentication failed', 500
data = response.json()
user = data['user']
# Store user in session
session['user'] = user
return redirect('/dashboard')
if __name__ == '__main__':
app.run(debug=True)
Error Responses
| Error Code | Description |
|---|---|
invalid_client |
Client ID or secret is invalid |
invalid_grant |
Authorization code is invalid or expired |
invalid_redirect_uri |
Redirect URI doesn't match registered URIs |
app_not_approved |
Your app is pending review or was denied |
access_denied |
User denied the authorization request |
Security Best Practices
- Keep your client secret secure. Never expose it in client-side code. Always make token exchange requests from your server.
- Always use HTTPS for your redirect URIs in production (localhost is allowed for development).
- Validate the state parameter to prevent CSRF attacks. Generate a unique state for each authorization request.
- Store tokens securely. Use HTTP-only cookies or secure server-side sessions.
- Handle errors gracefully. Don't expose detailed error messages to end users.
Need Help?
The Open Communication Protocol (OCP) standardizes communication between MIXERA hardware, accessories, and cloud services.
OCP API Status
Checking...
-
-
-
-
-
-
Table of Contents
1 Goals & Overview
Purpose
Standardize how the DJ controller communicates with:
- Cloud services (telemetry, stats, remote config)
- Connected PC (DAW, MIDI, GUI applications)
- Connected accessories (fader modules, jog wheels, extension PCBs)
Core Principles
- Simple, human-readable message format (JSON) with optional binary extension
- Explicit handshake: Exchange of Serial Number (SN) and Model Number (MN). Missing either allows usage — but with warning
- All cloud connections encrypted (minimum TLS 1.3). Sensitive data only transmitted pseudonymized
- Versioning and compatibility checks before executing critical commands
2 Actors & Transport Layers
Actors
e.g., Raspberry Pi 4 in the device
Motor fader boards, encoders, extensions
DAW, editor, debugging tools
Telemetry, auth, config, updates
Supported Transport Layers
| Connection | Transport Options |
|---|---|
| Controller ↔ Accessory | USB CDC (Serial), I²C/SPI (board-level), UART over GPIO. Optional: MIDI over USB / HID |
| Controller ↔ PC | USB (MIDI/CDC/HID) or WebSocket / TCP over LAN |
| Controller ↔ Cloud | HTTPS (REST), WebSocket over TLS, or MQTT over TLS (TLS 1.3 mandatory) |
Design Decision: Standardize on JSON over framed transport (e.g., length-prefixed), with optional CBOR/binary fallback for high performance.
3 Identification & Handshake
Goal: Ensure both sides know each other's SN & MN.
Principles
- Every unit has:
serial_number(globally unique),model_number,firmware_version(semver) - Handshake always at session start (e.g., after USB connect or TCP connect)
- If SN or MN is missing, handshake still proceeds — but the other side receives
compatibility_warning
Handshake Sequence
Connection established (USB serial open / TCP accept)
Both sides send HELLO with identity:
{
"type": "HELLO",
"payload": {
"serial_number": "MXR-20250701-000123",
"model_number": "MXR-DJCTRL-v2",
"firmware_version": "1.3.0",
"protocol_version": "1.0"
}
}
Receiver validates: known model? compatible protocol_version? (for Cloud: TLS session already established)
Response HELLO_ACK:
{
"type": "HELLO_ACK",
"payload": {
"accepted": true,
"compatibility": "FULL", // FULL | PARTIAL | UNKNOWN
"warnings": [],
"server_time": "2025-12-08T15:42:00Z"
}
}
Extended Authentication (Cloud)
Controller ↔ Cloud: After HELLO, use mTLS (client cert) or JWT-based auth.
Recommendation: Mutual TLS with device client certificate (provisioned in production). Fallback: token-based with rotating keys via PKI.
4 Message Types & Format
Base Format
{
"id": "uuid-v4",
"type": "EVENT" | "CMD" | "REQ" | "RESP" | "HEARTBEAT",
"ts": "2025-12-08T15:42:01Z",
"from": {"role":"controller","serial":"..."},
"to": {"role":"cloud"|"pc"|"accessory","serial":"..."},
"payload": { ... }
}
Message Types
HELLO/HELLO_ACK
— Handshake
CMD
— Control commands (e.g., SET_FADER_POS)
EVENT
— State changes (e.g., FADER_MOVED)
REQ/RESP
— Synchronous queries (e.g., GET_FIRMWARE)
TELEMETRY
— Regular stats to cloud
OTA
— Update commands (signed metadata + URL)
LOG
— Log messages (on demand)
Framing / Binary
- Local (Serial): length-prefixed JSON recommended (4-byte length + payload)
- High performance: CBOR/MsgPack optional, but JSON as baseline
5 Compatibility Check (Model Number)
MN determines compatibility: Controller holds compatibility matrix (model → supported features & firmware ranges).
Compatibility Levels
FULL
All features available, proceed normally
PARTIAL
Some features disabled; continue with warning
UNKNOWN
Proceed but mark telemetry as "unverified"
UI Behavior: Visible warning with option "Continue (unsafe)" or "Disconnect".
6 Warnings & Fallback Policy
When Serial Number is Missing
- Functionality: Full operation possible (if no security-critical functions)
- Policy: User-visible warning; cloud telemetry tagged
serial_missing - Reasoning: Allows developer boards & third-party accessories but retains traceability
When Model Number is Incompatible
- If critical mismatch (e.g., incompatible protocol version for motor control) → disable those features
- Otherwise → operate with reduced functionality
Warning Codes
| Code | Description |
|---|---|
W001 |
serial_missing |
W002 |
model_mismatch |
W003 |
protocol_version_mismatch |
W004 |
uncertified_certificate |
7 Cloud Security & Privacy (Mandatory)
- All cloud connections: TLS 1.3 mandatory, HTTP/2 optional
- Auth: Prefer mTLS (client cert) for device identity. Alternative: JWT signed by device private key; rotate tokens periodically
- Data minimization: Send only required telemetry (e.g., anonymize user IDs)
- Telemetry at rest: Encrypted (AES-256) and access-controlled
- PII policy: Never include owner email/name in periodic stats by default
- Audit logging for config changes & OTA
8 Telemetry / Stats Schema
Minimal Telemetry Event
{
"type": "TELEMETRY",
"payload": {
"device": {
"serial": "MXR-...",
"model": "MXR-DJCTRL-v2",
"fw": "1.3.0"
},
"uptime_seconds": 3600,
"events": {
"fader_moves": 1234,
"cpu_temp_c": 52.3
},
"health": {
"battery": 98,
"errors": []
}
}
}
- Frequency: Configurable (default: 1×/minute). Aggressive sampling only if user opted-in
- Bulk upload: Batch events with compression (gzip) and send over TLS
9 Auth & Key Management
- Device provisioning: Unique device private key + certificate signed by your CA
- Key rotation: Support for cert revocation via CRL/OCSP
- Device compromise: Support remote revoke & factory reset via cloud command
- Accessories without secure element: Mark as
untrusted_accessoryin cloud telemetry
10 OTA & Firmware Updates
- Update manifest signed (Ed25519 / RSA-4096)
- Controller verifies signature before applying
- Incompatibility check using MN +
min_fw_versionin manifest - Rollback plan and atomic update procedure
11 Error Codes, Retries & QoS
Standard Error Envelope
{ "code": 4001, "message": "MISSING_SERIAL", "fatal": false }
- Retries: Exponential backoff for network ops; for control commands prefer ACK/NAK pattern
- Heartbeat: Every 10s default; cloud expects at least 1/min
12 State Machine
On error → ERROR → possible RECOVERY or DISCONNECTED
13 Example: Local Fader Move
Fader board → Controller:
{
"type": "EVENT",
"payload": {"event": "FADER_MOVE", "chan": 3, "pos": 0.734}
}
Controller processes and forwards to PC GUI and (sampled) to Cloud:
{
"type": "TELEMETRY",
"payload": {
"events": [{"event": "FADER_MOVE", "chan": 3, "pos": 0.734, "ts": "..."}]
}
}
All cloud messages via HTTPS POST /v1/telemetry with TLS + client cert.
14 Backward / Forward Compatibility & Versioning
- Protocol uses
protocol_version(semantic major). Major changes increment major and trigger compatibility checks - Add
feature_flagsarray in HELLO to indicate supported optional features
15 UI/UX Recommendations for Warnings
- Warning color: Amber; short message: "Accessory unverified — some features may be limited. Continue?"
- If user continues, log consent in local device & cloud (timestamp + user action)
- Provide "trust this accessory" flow: user can accept and sign the accessory locally (store to whitelist)
16 Testing & Compliance Checklist
- Handshake tests: missing SN, missing MN, malformed JSON
- Security tests: TLS downgrade attempted, invalid cert, revoked cert
- Interoperability: test legacy accessories & new firmware combinations
- Telemetry privacy: verify PII absence
- OTA test: interrupt during update and verify rollback
17 Implementation Roadmap
18 Complete Handshake Example
Controller sends HELLO:
{
"id": "550e8400-e29b-41d4-a716-446655440000",
"type": "HELLO",
"ts": "2025-12-08T15:42:01Z",
"from": {"role": "controller", "serial": "MXR-20250701-000123"},
"to": {"role": "accessory"},
"payload": {
"model_number": "MXR-DJCTRL-v2",
"firmware_version": "1.3.0",
"protocol_version": "1.0",
"feature_flags": ["motorized_faders", "ota"]
}
}
Accessory responds HELLO_ACK (with missing serial):
{
"id": "...",
"type": "HELLO_ACK",
"ts": "2025-12-08T15:42:01Z",
"payload": {
"accepted": true,
"compatibility": "PARTIAL",
"warnings": [{"code": "W001", "message": "serial_missing"}]
}
}
Key Takeaways
- Always HELLO with SN + MN — but allow fallback with warning
- Cloud: Always TLS 1.3; prefer mTLS + signed OTA
- JSON framing as baseline; binary optional
- Version and compatibility checks before critical actions
Developer documentation for MIXERA OS — the embedded software platform running on MIXERA hardware. Covers the TCP backend API, real-time sync, AI stem separation, cloud track integration, and performance optimizations.
Table of Contents
1 TCP Backend API
MIXERA OS exposes a TCP socket on port 5555 with newline-delimited JSON events. All frontend UIs connect here for real-time control.
Connection
// Node.js
const net = require('net');
const socket = new net.Socket();
socket.connect(5555, 'localhost');
socket.setNoDelay(true); // Always enable TCP_NODELAY
// Browser (via WebSocket bridge)
const ws = new WebSocket('ws://localhost:5556');
Message Format
All messages are JSON terminated with \n:
// Send command
socket.write('play 0\n');
// Receive event
// {"event":"deck_status","data":{...}}
Core Commands
| Command | Parameters | Description |
|---|---|---|
| play | <deck> | Start playback on deck 0–3 |
| pause | <deck> | Pause playback |
| stop | <deck> | Stop and reset position |
| load_track | <deck> <path> | Load a local audio file |
| load_cloud_track | <deck> <trackId> | Download + load from cloud |
| ping | — | Heartbeat, responds with pong |
| get_deck_status | — | One-shot deck snapshot |
| get_waveform | <deck> [points] | Request waveform data |
| set_log | <type> <0|1> | Toggle event logging |
| stem_separate | <uid> <path> | Trigger AI stem separation |
| stem_load | <deck> <uid> | Load cached stems to deck |
| cloud_list_tracks | [limit] [offset] | List cloud library tracks |
2 Real-Time Sync & Low-Latency Communication
MIXERA OS provides 5 real-time communication features to eliminate perceived delay and enable smooth waveform sync:
Command Acknowledgment
After play/pause/stop/load_track, backend immediately sends cmd_ack. Always do optimistic UI updates — don't wait for ack.
Ping/Pong Heartbeat
Send ping\n every 2s. Backend responds with pong + timestamp. Use RTT for latency display and clock sync.
Deck Status Ticker (~30 Hz)
Backend continuously pushes deck_status at ~30 Hz with position, duration, and play state. Use interpolation for 60fps cursor.
Waveform Chunks
Waveform data arrives in ~500-point chunks via waveform_chunk events. Render progressively as chunks arrive.
cmd_ack Event
{"event":"cmd_ack","data":{"cmd":"play","deck_id":0,"ts_ms":1740000000000}}
deck_status Event (~30 Hz)
{"event":"deck_status","data":{"ts_ms":1740000000000,"decks":[
{"id":0,"position_sec":45.234,"total_sec":213.5,"playing":true},
{"id":1,"position_sec":0.000,"total_sec":0.000,"playing":false}
]}}
Position Interpolation (60fps cursor)
// Call in requestAnimationFrame — interpolates between 30Hz updates
function getInterpolatedPosition(deck) {
if (!deck.playing) return deck.position;
const elapsed = (Date.now() - deck.lastUpdateTime) / 1000;
return Math.min(deck.position + elapsed * deck.velocity, deck.total);
}
waveform_chunk Event
{"event":"waveform_chunk","data":{
"deck_id":0, "chunk_index":0, "total_chunks":4,
"sample_rate":44100, "total_points":2000,
"waveform":[0.012, 0.045, 0.078, ...]
}}
Backend Events Summary
| Event | Frequency | Key Data |
|---|---|---|
| cmd_ack | Per command | cmd, deck_id, ts_ms |
| pong | On ping | ts_ms |
| deck_status | ~30 Hz | decks[].position_sec, playing |
| waveform_progress | During load | deck_id, status, percent |
| waveform_chunk | Per chunk | waveform[], chunk_index, total_chunks |
3 Cloud Track API
After a successful OCP handshake, MIXERA OS can access the user's cloud library. All commands are sent over TCP port 5555.
Prerequisites
- Device registered to a Mixera account
- OCP handshake completed (HELLO/HELLO_ACK)
- Cloud access enabled in account settings
List Tracks
// Request first 50 tracks
socket.write("cloud_list_tracks 50 0\n");
// Response event:
{"event":"cloud_tracks_list","data":{"tracks":[
{"id":"track-123","title":"My Track","artist":"DJ Name",
"duration":240,"bpm":128.0,"key":"Am","genre":"Techno",
"fileSize":8388608,"format":"mp3"}
],"count":1}}
Get Metadata
socket.write("cloud_get_metadata track-123\n");
{"event":"cloud_track_metadata","data":{
"id":"track-123","title":"My Track","bpm":128.0,
"key":"Am","cuePoints":[{"time":0},{"time":32.5}],
"loops":[{"start":0,"end":8.0}]
}}
Search Tracks
// cloud_search_tracks <query> <genre> <bpmMin> <bpmMax> <limit>
socket.write("cloud_search_tracks house Techno 120 135 20\n");
Authentication Headers (Backend → Cloud)
The backend automatically adds X-OCP-Session, X-OCP-Token, and X-Device-Serial to all cloud API requests — you don't need to handle this in the frontend.
4 Load Cloud Track to Deck
The load_cloud_track command handles the full download-and-load pipeline automatically.
Command
// load_cloud_track <deck> <trackId>
socket.write("load_cloud_track 0 67980ec71648c734b60d9c06\n");
Event Flow
{"event":"cloud_track_loading","data":{"trackId":"...","deck":0,"status":"downloading"}}
{"event":"cloud_track_loading","data":{"trackId":"...","deck":0,"status":"loading"}}
{"event":"cloud_track_loaded","data":{"trackId":"...","deck":0,"filename":"My Track.mp3"}}
Downloaded tracks are cached locally at ~/.mixera_cache/cloud/<trackId>.mp3. Subsequent loads of the same track skip the download step.
5 AI Stem Separation (DEMUCS)
MIXERA OS integrates Meta's DEMUCS (Hybrid Transformer) for AI-powered separation into 4 stems: Vocals, Drums, Bass, Other.
Setup
# Install DEMUCS
pip install demucs
# GPU acceleration (10-20x faster)
pip install demucs torch --index-url https://download.pytorch.org/whl/cu121
# Verify
python -m demucs --help
IPC Commands
| Command | Description |
|---|---|
| stem_separate <uid> <path> | Queue track for AI separation |
| stem_status | Get separation queue status |
| stem_load <deck> <uid> | Load cached stems into deck |
| stem_algo <mode> | Switch algorithm: simple / enhanced / demucs |
| stem_clear_cache [uid] | Clear all or specific stem cache |
| demucs_check | Check DEMUCS installation |
Events
Processing Performance
| Hardware | Time / 5-min track |
|---|---|
| NVIDIA RTX 3080+ (GPU) | ~20–30 seconds |
| NVIDIA GTX 1060 (GPU) | ~60–90 seconds |
| CPU only (8-core) | ~3–5 minutes |
| CPU only (4-core) | ~5–10 minutes |
DEMUCS Models
6 Event Logging Control
Use set_log to enable or disable event categories at runtime, reducing log noise during development.
Command
// Syntax: set_log <type> <0|1>
// Types: audio, effects, hardware, analysis, all
socket.write('set_log all 0\n'); // Silence everything
socket.write('set_log analysis 1\n'); // Only show BPM/key results
socket.write('set_log audio 1\n'); // Debug audio events
socket.write('set_log hardware 1\n'); // Debug hardware input
Default State
Best Practice
// On connect: silence noise, keep important events
socket.write('set_log all 0\n');
socket.write('set_log analysis 1\n');
7 Device Management API
Link MIXERA hardware to user accounts to enable cloud library access, warranty tracking, and remote configuration.
Serial Number Format
MXR-YYYYMMDD-XXXXXX
Example: MXR-20250122-000001
Register Device
POST /api/devices/register
X-Session-Token: <token>
{"serialNumber":"MXR-20250122-000001","modelNumber":"MXR-CTRL-ONE",
"purchaseDate":"2025-01-22","nickname":"Studio Controller"}
Device Cloud Access (OCP Headers)
GET /api/device/cloud/tracks
X-OCP-Session: <session_id>
X-OCP-Token: <device_token>
X-Device-Serial: MXR-20250122-000001
Cloud Endpoints (Device → Cloud)
GET /api/device/cloud/tracksList tracks with paginationGET /api/device/cloud/tracks/:id/metadataBPM, key, cue points, loopsGET /api/device/cloud/tracks/:id/downloadSigned URL (1h expiry)GET /api/device/cloud/tracks/searchFilter by query, genre, BPM range8 Performance Optimizations
Applied optimizations that reduced frontend-backend latency from ~1 second to under 5ms:
Disabled Nagle's algorithm on all sockets. Eliminated 200ms packet buffering delay.
SO_SNDBUF/SO_RCVBUF set to 65536 bytes. Higher throughput for waveform data.
Cloud worker loop sleep reduced from 100ms → 1ms. Cloud requests now respond in <2ms.
recv() buffer increased from 512 → 8192 bytes. Fewer syscalls for large messages.
Frontend Performance Tips
- →Always set
setNoDelay(true)on the frontend socket - →Use
requestAnimationFrame+ interpolation for 60fps cursor, not 30Hz deck_status directly - →Render waveform progressively as chunks arrive — don't wait for all chunks
- →Optimistic UI updates on play/pause/stop — correct with cmd_ack only if needed
- →Debounce text displays to 10Hz max; animate canvas at 60fps
Live status overview of all MIXERA API services. Each endpoint is checked in real-time against the production server.
Note: Endpoints requiring authentication (marked with 🔒) are checked for reachability only — a 401 response still confirms the endpoint is live.
My Devices
Device Registration
Register your MIXERA devices to access cloud features, warranty info, and software updates. Devices can only be linked to one account at a time.
Manage your registered MIXERA devices, view warranty information, and download software updates.
Register New Device
No Devices Registered
Register your MIXERA device to access warranty info, software updates, and more.
Downloads & Resources
Select a device to view its specific firmware, manuals, and replacement parts.
Device Lock
Lock this device if stolen to prevent unauthorized use
Remove Device
Remove this device from your account
Remove Device
This will remove from your account. You can re-register it later.
Sustainability Dashboard PREVIEW
Track your environmental impact and see how MIXERA helps offset CO₂ emissions through tree planting.
Energy Used
By your MIXERA devices
0 kWh
≈ 0 kg CO₂ produced
Trees Planted
For your account
0 trees
≈ 0 kg CO₂ absorbed/year
Progress to Next Tree
Use 100 more kWh to plant another tree! 🌱
Your Forest
Each tree represents a real tree planted through our partnership with One Tree Planted 🌍
Your CO₂ Balance
Plant more trees to offset your carbon footprint!
MIXERA Community Impact
Together we're making a difference
0
Trees planted
0
Forests created
0
kg CO₂ absorbed/year
Community Forest Preview
Each 🌲 represents 10 trees (1 forest)
What MIXERA Does for the Planet
How it works
For every 100 kWh used by your MIXERA devices, we plant a tree through our partnership with One Tree Planted. Each tree absorbs approximately 22 kg of CO₂ per year, helping to offset your environmental impact.
Rent Technology PREVIEW
1. Event Details
Summary
2. Select Available Technology
Shopping Cart
Your cart is empty
Checkout (Preview)
Payment Method
This is a mock checkout. No real transaction will take place.
Booking Confirmed!
Your rental has been successfully booked. You will receive an email with all details shortly.
Danger Zone
Export Your Data
Download a copy of all data associated with your account.
Delete Account
Permanently delete your Mixera account and all associated data. This action cannot be undone.