Dacast

by Dacast-Inc

177 downloads

Not rated

GitHub

About

The Dacast MCP (Model Context Protocol) Server integrates Dacast’s comprehensive video streaming and hosting platform with your AI-powered applications. Once configured, you can upload and manage video content, control live streams, review analytics, and access nearly all of Daca

Details

Author: Dacast-Inc
Downloads: 177
Categories: Cloud Service, Other, Media, API

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Dacast

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "dacast": {
            "dacast": {
                "command": "go",
                "args": [
                    "run",
                    "github.com/Dacast-Inc/mcp-server-public@latest"
                ],
                "env": {
                    "DACAST_API_KEY": "DACAST API KEY HERE"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dacast": {
            "dacast": {
                "command": "go",
                "args": [
                    "run",
                    "github.com/Dacast-Inc/mcp-server-public@latest"
                ],
                "env": {
                    "DACAST_API_KEY": "DACAST API KEY HERE"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dacast": {
            "dacast": {
                "command": "go",
                "args": [
                    "run",
                    "github.com/Dacast-Inc/mcp-server-public@latest"
                ],
                "env": {
                    "DACAST_API_KEY": "DACAST API KEY HERE"
                }
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "dacast": {
            "dacast": {
                "command": "go",
                "args": [
                    "run",
                    "github.com/Dacast-Inc/mcp-server-public@latest"
                ],
                "env": {
                    "DACAST_API_KEY": "DACAST API KEY HERE"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dacast": {
            "dacast": {
                "command": "go",
                "args": [
                    "run",
                    "github.com/Dacast-Inc/mcp-server-public@latest"
                ],
                "env": {
                    "DACAST_API_KEY": "DACAST API KEY HERE"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dacast": {
            "dacast": {
                "command": "go",
                "args": [
                    "run",
                    "github.com/Dacast-Inc/mcp-server-public@latest"
                ],
                "env": {
                    "DACAST_API_KEY": "DACAST API KEY HERE"
                }
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "dacast": {
            "dacast": {
                "command": "go",
                "args": [
                    "run",
                    "github.com/Dacast-Inc/mcp-server-public@latest"
                ],
                "env": {
                    "DACAST_API_KEY": "DACAST API KEY HERE"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dacast": {
            "dacast": {
                "command": "go",
                "args": [
                    "run",
                    "github.com/Dacast-Inc/mcp-server-public@latest"
                ],
                "env": {
                    "DACAST_API_KEY": "DACAST API KEY HERE"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dacast": {
            "dacast": {
                "command": "go",
                "args": [
                    "run",
                    "github.com/Dacast-Inc/mcp-server-public@latest"
                ],
                "env": {
                    "DACAST_API_KEY": "DACAST API KEY HERE"
                }
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "dacast": {
            "dacast": {
                "command": "go",
                "args": [
                    "run",
                    "github.com/Dacast-Inc/mcp-server-public@latest"
                ],
                "env": {
                    "DACAST_API_KEY": "DACAST API KEY HERE"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dacast": {
            "dacast": {
                "command": "go",
                "args": [
                    "run",
                    "github.com/Dacast-Inc/mcp-server-public@latest"
                ],
                "env": {
                    "DACAST_API_KEY": "DACAST API KEY HERE"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dacast": {
            "dacast": {
                "command": "go",
                "args": [
                    "run",
                    "github.com/Dacast-Inc/mcp-server-public@latest"
                ],
                "env": {
                    "DACAST_API_KEY": "DACAST API KEY HERE"
                }
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "dacast": {
            "dacast": {
                "command": "go",
                "args": [
                    "run",
                    "github.com/Dacast-Inc/mcp-server-public@latest"
                ],
                "env": {
                    "DACAST_API_KEY": "DACAST API KEY HERE"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dacast": {
            "dacast": {
                "command": "go",
                "args": [
                    "run",
                    "github.com/Dacast-Inc/mcp-server-public@latest"
                ],
                "env": {
                    "DACAST_API_KEY": "DACAST API KEY HERE"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dacast": {
            "dacast": {
                "command": "go",
                "args": [
                    "run",
                    "github.com/Dacast-Inc/mcp-server-public@latest"
                ],
                "env": {
                    "DACAST_API_KEY": "DACAST API KEY HERE"
                }
            }
        }
    }
}

From the repository

Install with Go 1.24+ and a Dacast account with API key. Configure your MCP client (e.g., Claude Desktop) with the JSON configuration provided, setting the DACAST_API_KEY environment variable. Launch as a child process via go run github.com/Dacast-Inc/mcp-server-public@latest.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "dacast": {
            "dacast": {
                "command": "go",
                "args": [
                    "run",
                    "github.com/Dacast-Inc/mcp-server-public@latest"
                ],
                "env": {
                    "DACAST_API_KEY": "DACAST API KEY HERE"
                }
            }
        }
    }
}

McpServers

{
    "dacast": {
        "command": "go",
        "args": [
            "run",
            "github.com/Dacast-Inc/mcp-server-public@latest"
        ],
        "env": {
            "DACAST_API_KEY": "DACAST API KEY HERE"
        }
    }
}

What can you do with Dacast Live Stream MCP?

- Create and configure live channels— Ask your assistant to create a new channel, update its settings, or retrieve details usingcreate_channel,update_channel, andget_channel.
- Manage video playlists— Build playlists, modify their metadata, or define which videos they contain viacreate_playlist,update_playlist, andset_playlist_content.
- Handle thumbnail and splash images— Upload or update visual assets for your content using thethumbnailandsplashtools.
- Set up simulcast destinations— Create, check, or remove destinations for streaming to multiple platforms simultaneously withcreate_simulcast_destination,get_simulcast_destination, anddelete_simulcast_destination.

This repository provides aModel Context Protocol (MCP) serverthat exposes the Dacast video platform API as a set of structured MCP tools. It lets MCP-compatible clients (such as Claude Desktop) manage Dacast resources — channels, playlists, images, simulcast destinations, and more — through natural language.

- Speaks theModel Context Protocolover standard input/output.
- Designed to be launched by an MCP client process and kept running as a child process.

- Channel management: create, list, get, update.
- Playlist management: create, list, get, update, set playlist content.
- Image management: thumbnails and splash images.
- Simulcast destination management: create, get, delete.

- Go: Go 1.24+ (earlier versions may work but are not guaranteed).
- Dacast account and API key: required to perform authenticated operations.

JSON based MCP client configuration might look like:

{ "mcpServers": { "dacast": { "command": "go", "args": ["run", "github.com/Dacast-Inc/mcp-server-public@latest"], "env": { "DACAST_API_KEY": "DACAST API KEY HERE" } } } }

- Starts an MCP stdio server.
- Registers a set of tools grouped by Dacast domain (channels, playlists, images, simulcast).
- For each incoming MCPcall_toolrequest:

- Binds and validates the tool arguments.
- Constructs an HTTP request to the relevant Dacast REST endpoint using the internalApiClient.
- Forwards the request to Dacast with the appropriate authentication headers.
- Returns the JSON response (and optionally a transformed, structured form) back to the MCP client.

- main.go– entrypoint that initializes the MCP server and registers tools.
- pkg/apiclient/– minimal HTTP client wrapper around the Dacast REST API.
- pkg/tools/– tool implementations grouped by domain:

- channel/– channel-related operations.
- playlist/– playlist-related operations.
- images/– thumbnail and splash image operations.
- simulcast/– simulcast destination operations.

Each tool underpkg/tools/corresponds to one or more Dacast API endpoints.

- create_channel.go– create a new channel.
- get_channel.go– get channel details.
- update_channel.go– update an existing channel.
- list_channel.go– list all or filtered channels.

- create_playlist.go– create a new playlist.
- get_playlist.go– get playlist details.
- update_playlist.go– update an existing playlist.
- list_playlist.go– list playlists.
- set_playlist_content.go– set or update playlist content.

- thumbnail.go– manage channel/asset thumbnails.
- splash.go– manage splash images.

- create_simulcast_destination.go– create a simulcast destination.
- get_simulcast_destination.go– retrieve a simulcast destination.
- delete_simulcast_destination.go– delete a simulcast destination.

This project is licensed under the terms described in theLICENSEfile in this repository. Please review that file for the full text.

34-tool MCP server for CutPro's v1 API — analyze videos, clip, render, and publish posts via AI clients like Claude, ChatGPT, and Cursor.

Render videos from JSON via the iLoveVideoEditor cloud API: motion-design templates, GPU effects, transitions, batch rendering, webhooks.

Generate, edit, and render videos, images, and audio from Claude, Cursor, ChatGPT and other AI tools via the Shotstack video editing API.

Interact with Cloudinary's media management platform using natural language.

Turn any language model into a multimodal powerhouse that can generate images, music, videos and more on the fly. Rostro's tools are designed to be used by language models from the ground up, expanding capabilities with minimal context bloat.

Analyzes image and video content from URLs or local files using the Gemini 2.0 Flash model.

A server for performing secure, read-only operations on the Kaltura API.

Generate videos from images and manage tasks using the Vidu video generation API.

Create AI music videos and audio-reactive visuals from songs through MCP.

Server for advanced AI-driven video editing, semantic search, multilingual transcription, generative media, voice cloning, and content moderation.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

What can you do with Dacast Live Stream MCP?

Install

More like this

Sequential Thinking

Aws Kb Retrieval Server

Filesystem

EverArt

Google Maps

Google Drive