Which integrations are available for this server?

Provides tools for controlling and automating OBS Studio, including scene and source management, audio control, recording/streaming, transitions, filters, media playback, and diagnostics via OBS WebSocket.

How do I use OBS MCP?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@OBS MCP Start recording and switch to the Coding scene" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

OBS MCP

by KshamayBharadwaj

Overview Schema Source Related Servers Discussions Admin

Python

Hybrid

OBS MCP — AI Broadcast Control & Automation for OBS Studio

An MCP (Model Context Protocol) server that turns an AI assistant into an AI broadcast operator for OBS Studio. Describe what you want in natural language — the server handles scenes, sources, audio, recording, streaming, transitions, filters, media playback, diagnostics and multi-step workflows over the OBS WebSocket 5.x protocol.

AI Assistant (Claude, opencode, Cursor, ...)
        │  MCP (stdio / sse / streamable-http)
        ▼
    OBS MCP Server
    ┌─────────────────────────────┐
    │ Control / Monitoring        │
    │ Diagnostics / Automation    │
    │ Safety layer (confirmation) │
    └──────────────┬──────────────┘
                   │ OBS WebSocket (default port 4455)
                   ▼
              OBS Studio
           (obs-websocket)

89 tools, 107 tests, no OBS required to run the test suite.

Related MCP server: OBS MCP

What you can do

Connection & status get_obs_status · get_obs_stats · obs_help

Scene management list_scenes · get_current_scene · switch_scene · create_scene · rename_scene · delete_scene · duplicate_scene · get_scene_sources · add_source_to_scene · remove_source_from_scene

Source (input) management list_sources · get_source · get_source_available_kinds · create_source · update_source · delete_source · duplicate_source · show_source · hide_source · set_source_visibility_in_all_scenes

Positioning & layout get_source_transform · set_source_transform (move / scale / rotate / crop) · set_source_index (z-order)

Transitions & studio mode get_transitions · set_scene_transition · set_transition_duration · get_studio_mode_status · set_studio_mode · set_preview_scene · trigger_transition

Audio list_audio_sources · get_audio_status · get_volume · set_volume · mute_source · unmute_source · set_audio_monitor · set_audio_sync_offset · set_audio_track

Filters list_filters · add_filter · remove_filter · get_filter_settings · set_filter_settings · reorder_filters · toggle_filter

Recording & replay buffer get_recording_status · start_recording · stop_recording · pause_recording · resume_recording · get_record_directory · set_record_directory · get_replay_buffer_status · start_replay_buffer · stop_replay_buffer · save_replay_buffer

Streaming get_stream_status · start_stream · stop_stream · get_stream_health · get_stream_service_settings · set_stream_settings · get_output_settings · set_output_settings

Media & VLC playback media_control (play / pause / stop / restart / next / previous) · get_media_time · set_media_time

Hotkeys & configuration get_hotkey_list · trigger_hotkey · get_video_settings · set_video_settings · list_profiles · set_current_profile · create_profile · list_scene_collections · set_current_scene_collection · create_scene_collection

Diagnostics diagnose_obs (full health check) · diagnose_stream · diagnose_recording · diagnose_audio

Automation workflows prepare_recording · prepare_stream · start_recording_session · end_session

Requirements

Python 3.10+
OBS Studio (any recent version — 28+; tested on 32.x) with the built-in WebSocket server enabled
One of these AI assistants (any MCP client works):
- opencode
- Claude Desktop
- Cursor
- Any MCP-capable client

Setup OBS (do this first)

Install OBS Studio from obsproject.com.
Enable the WebSocket server:
- OBS menu: Tools → WebSocket Server Settings…
- Check Enable WebSocket server
- Note the Server Port (default 4455)
- Check Require authentication and set a password — the server refuses to connect without credentials for security reasons. Save it; you will need it in the next step.
Prepare your scenes and sources (optional but recommended):
- Create scenes (e.g. Intro, Coding, BrB) via Scene dock or + button in the Sources dock.
- Add sources (webcam, display capture, audio, media) and arrange them.
- If you plan to use the automation workflows, decide which scene is the "recording scene" and which is the "stream scene".
Leave OBS running while you use the AI assistant. The server connects lazily and reconnects automatically if OBS restarts.
(Optional) To verify everything works before wiring the AI assistant, run the included demo client — see Testing.

Installation

git clone <this-repo> && cd obs-mcp
python3 -m venv .venv
source .venv/bin/activate
pip install -e .

This installs the obs-mcp command into the virtual environment (.venv/bin/obs-mcp). All examples below assume the venv is active or use the full path .venv/bin/obs-mcp.

Configuration

Copy the example file and fill in your OBS WebSocket password:

cp .env.example .env
# edit .env, set OBS_PASSWORD to the password you configured in OBS

The server reads the .env file in the project directory, plus any OBS_* environment variables you export (environment variables win).

Variable	Default	Description
`OBS_HOST`	`localhost`	OBS WebSocket host
`OBS_PORT`	`4455`	OBS WebSocket port (must match Tools → WebSocket Server Settings)
`OBS_PASSWORD`	(empty)	WebSocket auth password — required when OBS requires authentication
`OBS_REQUIRE_CONFIRMATION_HIGH`	`true`	Gate high-risk ops (stream start/stop, deletes) behind `confirm=True`
`OBS_REQUIRE_CONFIRMATION_MEDIUM`	`false`	Gate medium-risk ops (audio, recording) behind `confirm=True`
`OBS_CONNECT_TIMEOUT`	`5`	Seconds to wait for a connection attempt
`OBS_RECORDING_SCENE`	(empty)	Scene used by `prepare_recording` / `start_recording_session` (empty = current scene)
`OBS_STREAM_SCENE`	(empty)	Scene used by `prepare_stream` (empty = current scene)
`OBS_LOG_LEVEL`	`INFO`	Logging verbosity: `DEBUG`, `INFO`, `WARNING`, `ERROR`

Security note

OBS_PASSWORD is the same credential that grants full control of your OBS instance (start streams, delete scenes). Never commit it to version control (.env is git-ignored), and use a strong password if your machine is network-exposed.

Connecting an AI assistant (MCP client)

opencode

Add a mcp entry to opencode.json (usually ~/.config/opencode/opencode.json):

{
  "mcp": {
    "obs-mcp": {
      "type": "local",
      "command": [
        "/path/to/obs-mcp/.venv/bin/obs-mcp"
      ],
      "enabled": true,
      "environment": {
        "OBS_HOST": "localhost",
        "OBS_PORT": "4455",
        "OBS_PASSWORD": "your-obs-websocket-password"
      }
    }
  }
}

Restart opencode, then ask it things like "check OBS status".

Claude Desktop

Add to claude_desktop_config.json (Claude → Settings → Developer):

{
  "mcpServers": {
    "obs-mcp": {
      "command": "/path/to/obs-mcp/.venv/bin/obs-mcp",
      "args": [],
      "env": {
        "OBS_HOST": "localhost",
        "OBS_PORT": "4455",
        "OBS_PASSWORD": "your-obs-websocket-password"
      }
    }
  }
}

Other clients (Cursor, VS Code, generic)

Point the client at the stdio binary. If your client only supports HTTP servers, run the server with --transport sse or --transport streamable-http and give it the URL of the running server.

Running the server

The server is normally launched by your MCP client, but you can also run it standalone to check it starts cleanly:

obs-mcp                          # stdio transport (default, what MCP clients use)
obs-mcp --transport sse          # SSE HTTP transport
obs-mcp --transport streamable-http
python -m server.mcp_server      # equivalent to obs-mcp

A successful stdio start prints nothing but the MCP handshake — clients usually show the server as connected. You can verify OBS connectivity by calling get_obs_status from your assistant, or by running the demo client (needs OBS running):

python examples/demo_client.py

Safety model

Operations are classified by risk in server/safety/permissions.py:

Level	Examples	Default policy
Low	status, lists, `get_*`, switch scene, show/hide source	runs automatically
Medium	volume/mute, create/rename scene, source settings, recording	runs automatically (can be gated via `OBS_REQUIRE_CONFIRMATION_MEDIUM=true`)
High	start/stop stream, delete scene/source, `end_session`	requires `confirm=true`

High-risk tools return confirmation_required unless the caller passes confirm=True — i.e. the AI asks the human first, then proceeds only with explicit confirmation.

Example session

User: Check OBS.
AI: OBS is connected. Current scene: Coding. Microphone: Active. Webcam: Active. Recording: OFF. Streaming: OFF.
User: Add a camera in the bottom-right corner of Scene 2 with a full-screen background.
AI: creates a Background color source (1920×1080) and the webcam source, then positions the camera at the bottom-right using set_source_transform.
User: Prepare my coding recording.
AI: calls prepare_recording, reports the setup summary.
User: Everything looks good. Start recording.
AI: calls start_recording_session with confirm=True after asking, confirms, and reports the recording is live.
User: Stop recording and give me a summary.
AI: calls end_session, returns duration and the saved file path.

Testing

pip install -e ".[dev]"
pytest

Run the tests from the project root. The suite (107 tests) runs against an in-memory fake OBS — no OBS needed — plus one end-to-end test over the real stdio MCP transport.

Project structure

obs-mcp/
├── server/
│   ├── mcp_server.py        # MCP wiring, tool registration, entry point
│   ├── obs_client.py        # OBS WebSocket connection, auth, reconnect, helpers
│   ├── config.py            # OBS_* environment configuration
│   ├── tools/               # one module per feature area
│   │   ├── scenes.py  sources.py  audio.py
│   │   ├── recording.py  streaming.py  transitions helpers
│   │   ├── media.py  filters.py  config.py
│   │   ├── diagnostics.py  automation.py
│   ├── safety/permissions.py  # risk classification + confirmation policy
│   └── models/responses.py    # structured tool responses
├── tests/                   # pytest suite with an in-memory fake OBS
├── examples/demo_client.py  # stdio demo client
├── pyproject.toml
├── features.txt             # full feature checklist
└── .env.example

Troubleshooting

Problem	Fix
`get_obs_status` reports "Could not reach OBS"	OBS not running, or WebSocket server disabled (Tools → WebSocket Server Settings → Enable WebSocket server)
Authentication failed	`OBS_PASSWORD` does not match the password in OBS WebSocket settings — check both, restart OBS after changing it
Connection refused on a remote machine	Check `OBS_HOST`/`OBS_PORT`; make sure the port is reachable and OBS is listening on it
Tools return `confirmation_required`	The operation is high-risk — pass `confirm=true` to execute it
`set_source_transform` does nothing	Keys are snake_case (`position_x`, `scale_y`, `bounds_width`, …); the server converts them for the OBS protocol
Media source won't play	`media_control` uses `OBS_WEBSOCKET_MEDIA_INPUT_ACTION_*` actions on media-capable sources (ffmpeg_source / VLC); `set_media_time` needs the source playing or paused
Assistant can't find the tools after adding the server	Restart the MCP client so it re-reads the config
Tests fail when run from another directory	Always run `pytest` from the project root

Available Tools

89 tools

add_filterAdd filterB

Add a filter to a source, e.g. chroma_key_v3, noise_suppress_v2, gain_filter, color_filter. Optionally pass settings.

Inputs: filter_kind (required), filter_name (required), source_name (required), confirm, +1 more. Returns: result

add_source_to_sceneAdd source to sceneB

Add an existing source to a scene (as a new scene item).

Inputs: scene_name (required), source_name (required), confirm, enabled. Returns: result

create_profileCreate profileB

Create a new OBS profile. Medium risk.

Inputs: profile_name (required), confirm. Returns: result

create_sceneCreate sceneB

Create a new empty scene.

Inputs: scene_name (required). Returns: result

create_scene_collectionCreate scene collectionB

Create a new OBS scene collection. Medium risk.

Inputs: collection_name (required), confirm. Returns: result

create_sourceCreate sourceC

Create a new source (input) and add it to a scene.

Inputs: kind (required), scene_name (required), source_name (required), confirm, +2 more. Returns: result

delete_sceneDelete sceneA

Permanently remove a scene. High-impact: requires confirmation.

Inputs: scene_name (required), confirm. Returns: result

delete_sourceDelete sourceA

Permanently remove a source. High-impact: requires confirmation.

Inputs: source_name (required), confirm. Returns: result

diagnose_audioDiagnose audioA

Diagnose audio problems: muted sources, missing devices.

Inputs: no named parameters. Returns: result

diagnose_obsDiagnose OBSA

Full OBS health check: connection, scene, recording, streaming, FPS, CPU, memory, dropped frames, audio. Returns a structured report.

Inputs: no named parameters. Returns: result

diagnose_recordingDiagnose recordingA

Diagnose recording problems: output state, disk, FPS.

Inputs: no named parameters. Returns: result

diagnose_streamDiagnose streamA

Diagnose streaming problems: drops, congestion, encoder.

Inputs: no named parameters. Returns: result

duplicate_sceneDuplicate sceneA

Duplicate a scene and all of its sources into a new scene (optionally with a custom name).

Inputs: scene_name (required), confirm, new_name. Returns: result

duplicate_sourceDuplicate sourceB

Duplicate a source with its settings (optionally into a scene, optionally under a new name).

Inputs: source_name (required), confirm, new_name, scene_name. Returns: result

end_sessionEnd sessionA

Stop recording and/or streaming after confirmation and return a final session summary with duration and statistics.

Inputs: confirm, stop_recording, stop_streaming. Returns: result

get_audio_statusAudio statusA

Overall audio status: mute/volume of all audio-capable sources.

Inputs: no named parameters. Returns: result

get_current_sceneGet current sceneA

Return the currently active program scene.

Inputs: no named parameters. Returns: result

get_filter_settingsGet filter settingsA

Get the settings and state of one filter on a source.

Inputs: filter_name (required), source_name (required). Returns: result

get_hotkey_listList hotkeysA

List all hotkeys defined in OBS.

Inputs: no named parameters. Returns: result

get_media_timeGet media timeA

Get the current playback position and duration of a media source.

Inputs: source_name (required). Returns: result

get_obs_statsOBS statisticsA

Raw OBS statistics: CPU, memory, FPS, render/output drops.

Inputs: no named parameters. Returns: result

get_obs_statusOBS statusA

Overall OBS status: connection, OBS version, current scene, recording/streaming state and key stats. Example: 'Is OBS connected?'

Inputs: no named parameters. Returns: result

get_output_settingsGet output settingsA

Get the settings of an OBS output (e.g. adv_stream, adv_file_output).

Inputs: output_name (required). Returns: result

get_record_directoryGet record directoryA

Get the folder where recordings are saved.

Inputs: no named parameters. Returns: result

get_recording_statusRecording statusA

Get whether OBS is recording, paused, and for how long.

Inputs: no named parameters. Returns: result

get_replay_buffer_statusReplay buffer statusA

Get whether the replay buffer is active or saving.

Inputs: no named parameters. Returns: result

get_scene_sourcesInspect scene sourcesA

List sources (scene items) inside a scene, with visibility.

Inputs: scene_name (required). Returns: result

get_sourceGet source stateC

Get the settings and visibility state of one source.

Inputs: source_name (required), scene_name. Returns: result

get_source_available_kindsList source kindsA

List all source types (input kinds) that OBS supports.

Inputs: no named parameters. Returns: result

get_source_transformGet source transformB

Get the position, scale, rotation and crop of a source in a scene.

Inputs: scene_name (required), source_name (required). Returns: result

get_stream_healthStream healthA

Check stream health: dropped frames, congestion, reconnects.

Inputs: no named parameters. Returns: result

get_stream_service_settingsStream destinationA

Inspect the stream service type and configured settings.

Inputs: no named parameters. Returns: result

get_stream_statusStream statusA

Get whether OBS is live, reconnecting, and stream duration.

Inputs: no named parameters. Returns: result

get_studio_mode_statusStudio mode statusA

Return whether studio mode is enabled, plus the current preview and program scenes.

Inputs: no named parameters. Returns: result

get_transitionsList scene transitionsA

List available scene transitions and the active one.

Inputs: no named parameters. Returns: result

get_video_settingsGet video settingsC

Canvas resolution, output resolution and FPS.

Inputs: no named parameters. Returns: result

get_volumeGet volumeA

Get the current volume of an audio source (multiplier and dB).

Inputs: source_name (required). Returns: result

hide_sourceHide sourceB

Hide a source in a scene. Example: 'Turn off my webcam.'

Inputs: scene_name (required), source_name (required). Returns: result

list_audio_sourcesList audio sourcesA

List all audio sources with their mute and volume state.

Inputs: no named parameters. Returns: result

list_filtersList source filtersA

List all filters attached to a source with their state.

Inputs: source_name (required). Returns: result

list_profilesList profilesA

List all OBS profiles and the active one.

Inputs: no named parameters. Returns: result

list_scene_collectionsList scene collectionsA

List all OBS scene collections and the active one.

Inputs: no named parameters. Returns: result

list_scenesList scenesA

List every scene in OBS with its index.

Inputs: no named parameters. Returns: result

list_sourcesList sourcesA

List all sources (inputs) in OBS with their kind.

Inputs: no named parameters. Returns: result

media_controlControl media sourceB

Play, pause, stop, restart, or skip a media/VLC source. Actions: PLAY, PAUSE, STOP, RESTART, NEXT, PREVIOUS.

Inputs: action (required), source_name (required). Returns: result

mute_sourceMute sourceC

Mute an audio source.

Inputs: source_name (required), confirm. Returns: result

obs_helpMCP tool indexA

List every available OBS MCP tool with a short description.

Inputs: no named parameters. Returns: result

pause_recordingPause recordingA

Pause the active recording.

Inputs: no named parameters. Returns: result

prepare_recordingPrepare recordingA

Prepare OBS for recording: switch to the recording scene, verify sources, check audio and readiness, then report a setup summary. Does NOT start recording.

Inputs: no named parameters. Returns: result

prepare_streamPrepare streamA

Prepare OBS for streaming: switch to the stream scene, verify sources and audio, check output configuration, then report readiness. Does NOT go live.

Inputs: no named parameters. Returns: result

remove_filterRemove filterB

Remove a filter from a source. High-impact: requires confirmation.

Inputs: filter_name (required), source_name (required), confirm. Returns: result

remove_source_from_sceneRemove source from sceneA

Remove a source from a scene without deleting the source itself. High-impact: requires confirmation.

Inputs: scene_name (required), source_name (required), confirm. Returns: result

rename_sceneRename sceneC

Rename an existing scene.

Inputs: new_name (required), scene_name (required). Returns: result

reorder_filtersReorder filtersB

Set the processing order (index) of a filter on a source.

Inputs: index (required), filter_name (required), source_name (required). Returns: result

resume_recordingResume recordingA

Resume the paused recording.

Inputs: no named parameters. Returns: result

save_replay_bufferSave replay bufferA

Save the current replay buffer to disk (the buffer keeps recording afterwards).

Inputs: no named parameters. Returns: result

set_audio_monitorSet audio monitor modeA

Set how a source's audio is monitored: NONE (off), MONITOR_ONLY (hear only), or MONITOR_AND_OUTPUT (hear and broadcast).

Inputs: source_name (required), monitor_type (required). Returns: result

set_audio_sync_offsetSet audio sync offsetA

Set an audio sync offset in milliseconds for a source. Positive delays audio, negative advances it.

Inputs: offset_ms (required), source_name (required). Returns: result

set_audio_trackSet audio tracksA

Enable or disable audio tracks 1-6 for a source. Pass a dict like {'1': True, '2': False}.

Inputs: tracks (required), source_name (required). Returns: result

set_current_profileSwitch profileB

Switch to another OBS profile. Medium risk.

Inputs: profile_name (required), confirm. Returns: result

set_current_scene_collectionSwitch scene collectionB

Switch to another OBS scene collection. High impact.

Inputs: collection_name (required), confirm. Returns: result

set_filter_settingsSet filter settingsB

Modify the settings of a filter on a source.

Inputs: filter_name (required), source_name (required), filter_settings (required), confirm, +1 more. Returns: result

set_media_timeSeek media sourceC

Seek a media source to a specific time in milliseconds.

Inputs: time_ms (required), source_name (required). Returns: result

set_output_settingsSet output settingsC

Modify settings of an OBS output (bitrate, encoder, etc.). Medium risk.

Inputs: output_name (required), output_settings (required), confirm. Returns: result

set_preview_sceneSet preview sceneB

Set the preview scene while studio mode is enabled.

Inputs: scene_name (required). Returns: result

set_record_directorySet record directoryB

Change the folder where recordings are saved.

Inputs: path (required), confirm. Returns: result

set_scene_transitionSet scene transitionB

Set the transition used when switching scenes.

Inputs: transition_name (required). Returns: result

set_source_indexReorder source in sceneA

Change the stacking order (z-order) of a source in a scene. Index 0 is at the back; higher indexes are drawn on top. Example: 'Send my webcam to the front in the Coding scene.'

Inputs: index (required), scene_name (required), source_name (required). Returns: result

set_source_transformSet source transformA

Move, scale, rotate or crop a source in a scene. Pass any subset of position_x/position_y, scale_x/scale_y, rotation, width/height, bounds_type/bounds_width/bounds_height, crop_left/right/top/bottom, alignment. Example: 'Put my webcam in the bottom right corner, 320x180.'

Inputs: transform (required), scene_name (required), source_name (required), confirm. Returns: result

set_source_visibility_in_all_scenesShow/hide source in all scenesA

Make a source visible or hidden in every scene that contains it. Example: 'Turn off my webcam everywhere.'

Inputs: visible (required), source_name (required). Returns: result

set_stream_settingsSet stream destinationA

Set the stream service and its settings (server URL, stream key, service name, etc.). Example: 'Set my stream key to X on rtmp://ingest.example.com/live'.

Inputs: settings (required), service_type (required). Returns: result

set_studio_modeToggle studio modeA

Enable or disable studio mode (preview/program layout).

Inputs: enabled (required). Returns: result

set_transition_durationSet transition durationB

Set the duration (ms) of the active scene transition.

Inputs: duration_ms (required). Returns: result

set_video_settingsSet video settingsB

Change canvas/output resolution or FPS. Pass any subset of base_width/base_height, output_width/output_height, fps_numerator/fps_denominator. Medium risk.

Inputs: video_settings (required), confirm. Returns: result

set_volumeSet volumeA

Set the volume of an audio source. Provide volume_percent (0-100) or volume_db directly. Example: 'set my microphone to 70%'.

Inputs: source_name (required), confirm, volume_db, volume_percent. Returns: result

show_sourceShow sourceA

Make a source visible in a scene. Example: 'Show my webcam in the Coding scene.'

Inputs: scene_name (required), source_name (required). Returns: result

start_recordingStart recordingA

Start recording. Medium impact: may require confirmation.

Inputs: confirm. Returns: result

start_recording_sessionStart recording sessionA

Full recording workflow: prepare the scene, verify sources and audio, check health, then start recording. High impact: requires explicit confirmation.

Inputs: confirm. Returns: result

start_replay_bufferStart replay bufferA

Start the replay buffer (requires it to be enabled in OBS).

Inputs: no named parameters. Returns: result

start_streamStart streamA

Start the live stream. HIGH IMPACT: going live is visible to viewers, so explicit user confirmation is required.

Inputs: confirm. Returns: result

stop_recordingStop recordingC

Stop the current recording and return the saved file path.

Inputs: confirm. Returns: result

stop_replay_bufferStop replay bufferB

Stop the replay buffer.

Inputs: no named parameters. Returns: result

stop_streamStop streamA

Stop the live stream. HIGH IMPACT: ends the broadcast for all viewers, so explicit user confirmation is required.

Inputs: confirm. Returns: result

switch_sceneSwitch sceneA

Switch to another scene. Example: 'Switch to my Gaming scene.'

Inputs: scene_name (required). Returns: result

toggle_filterEnable/disable filterB

Enable or disable a filter on a source.

Inputs: enabled (required), filter_name (required), source_name (required). Returns: result

trigger_hotkeyTrigger hotkeyB

Trigger a hotkey by its name (e.g. 'Start Recording').

Inputs: hotkey_name (required). Returns: result

trigger_transitionTrigger transitionB

Execute a manual studio-mode transition (preview becomes program).

Inputs: confirm. Returns: result

unmute_sourceUnmute sourceC

Unmute an audio source.

Inputs: source_name (required), confirm. Returns: result

update_sourceUpdate source settingsC

Modify source properties (e.g. capture settings). Medium risk.

Inputs: source_name (required), source_settings (required), confirm, overlay. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

B3.2/5.0

Scored 2026-08-14 16:40 across 89 tools

Disambiguation4/5

Tools are generally well-separated by resource and action, but some overlap exists (e.g., get_obs_stats vs get_obs_status vs diagnose_obs; start_recording vs start_recording_session). Descriptions help clarify these boundaries, making accidental misselection unlikely.

Naming Consistency4/5

Most tools follow a consistent verb_noun snake_case pattern (get_, set_, create_, delete_, start_, stop_, etc.). Minor exceptions like 'media_control' and 'obs_help' invert the pattern, but the overall style is uniform.

Tool Count2/5

With 89 tools, the server is extremely large. While OBS has many features, the sheer number of tools is excessive, and some could be consolidated (e.g., diagnostic tools could use a single parameterized endpoint). This is well beyond the 25+ threshold for 'too many'.

Completeness5/5

The tool surface covers virtually every major OBS domain: scenes, sources, audio, video, media, filters, transitions, studio mode, profiles, collections, recording, streaming, replay buffer, hotkeys, and diagnostics. It even includes higher-level session workflows, leaving no obvious gaps for typical automation.

Maintenance

ActivityInactive

ResponsivenessNo recent community issues

Resources

Related MCP Connectors

StreamScanner
net.streamscanner
Query your Twitch streams, events, supporters, raids & rankings from an AI assistant via OAuth.
Entertainment & Media Social Media
2
https://streamscanner.net/mcp
PC Remote Commander
io.github.pcremotecommander
Connect AI assistants to your approved computer for files, commands, browser and desktop tasks.
File Systems Command Line Browser Automation
11
https://pc-remote-commander.pcremotecommander.workers.dev/mcp
apiai.me
me.apiai
Image and video AI tools and your own pipelines, run from any AI assistant.
Image & Video Processing AI & Machine Learning
1
https://apiai.me/api/mcp
Upstream.so
so.upstream
Manage 24/7 live streams, media, playback queues, schedules, and multistreaming from AI assistants.
Entertainment & Media Multimedia Processing Command Line
11
https://studio.upstream.so/mcp

Related MCP Servers

OBS MCP
Entertainment & Media Multimedia Processing
xDarkzx
A
license
B
quality
B
maintenance
AI-powered stream and recording control for OBS Studio through the Model Context Protocol
Updated a month ago (2026-10-14 04:07 UTC)
100
28
Apache 2.0
OBS MCP
Multimedia Processing Entertainment & Media
Tom-R-Main
A
license
B
quality
B
maintenance
Enables MCP clients to control OBS Studio through an inspectable WebSocket interface. Provides 155 tools for managing scenes, sources, audio, transitions, filters, recording, and streaming through natural language.
Updated 3 days ago (2026-11-11 13:06 UTC)
155
598 npm
4
MIT
obs-mcp
App Automation Multimedia Processing Autonomous Agents
LHenri88
A
license
Not graded
quality
C
maintenance
Enables an LLM agent to control a local OBS Studio instance via obs-websocket, launching it, arranging scenes and sources, and starting or stopping recordings so it can capture its own screen as raw footage without manual intervention.
Updated a month ago (2026-10-04 17:35 UTC)
1
MIT
obs-control-mcp
Multimedia Processing App Automation
rjla-developer
A
license
A
quality
C
maintenance
Enables AI assistants to inspect and safely control OBS Studio over obs-websocket v5, exposing scenes, inputs, filters, outputs and video settings as read and write tools that default to dry runs and refuse changes while live unless explicitly confirmed. It also provides Source Record and IRL readiness checks, a BRB auto-switcher, and a scene timeline log for cutting clips from VODs.
Updated a month ago (2026-10-03 19:10 UTC)
17
MIT

OBS MCP — AI Broadcast Control & Automation for OBS Studio

Table of contents

What you can do

Requirements

Setup OBS (do this first)

Installation

Configuration

Security note

Connecting an AI assistant (MCP client)

opencode

Claude Desktop

Other clients (Cursor, VS Code, generic)

Running the server

Safety model

Example session

Testing

Project structure

Troubleshooting

Available Tools

Tool Schema Changelog

TDQS

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

OBS MCP

OBS MCP

obs-mcp

obs-control-mcp