Qencode MCP for AI. Automate Transcoding and Live Simulcasting via API
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Connect to your AI in seconds.
Qencode automates high-performance video transcoding and live broadcasting using your AI client. Manage complex tasks—from creating custom CDN domains to running simulcasts on Twitch or YouTube—all through natural conversation with no command line required.
It handles the entire media pipeline.
What your AI can do
Add simulcast target
Adds a specific restreaming destination (like Twitch or YouTube) to an active live stream.
Create domain
Creates and registers a custom Content Delivery Network (CDN) domain for your content.
Create live stream
Sets up a brand new live stream instance, requiring a valid live access token.
Your agent creates new encoding tasks using create_task and starts them with parameters via start_encode. You can track progress for multiple running videos using get_task_status.
You establish a new live stream instance using create_live_stream, specifying the necessary protocols (RTMP, WebRTC) and delivery formats.
The agent adds restreaming destinations like YouTube or Twitch to an existing broadcast using add_simulcast_target.
You can start a feed with start_live_stream, modify its settings with update_live_stream, and shut it down cleanly using stop_live_stream.
The agent handles the creation of custom CDN domains using create_domain, which is necessary for reliable content delivery.
Ask an AI about this
Waiting for input…
Qencode MCP Server: 11 Tools for Video Ops
These tools allow your AI client to manage every stage of video delivery—from initial task creation and status checks to setting up multi-platform live broadcasts.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Qencode on VinkiusAdd Simulcast Target
Adds a specific restreaming destination (like Twitch or YouTube) to an active live stream.
Create Domain
Creates and registers a custom Content Delivery Network (CDN) domain for your...
Create Live Stream
Sets up a brand new live stream instance, requiring a valid live access token.
Create Task
Initializes and registers a new transcoding job, allowing you to define source and...
Get Access Token
Retrieves a session-based access token required before running any transcoding tasks.
Get Live Access Token
Gets an access token needed specifically for managing and operating live streams.
Get Task Status
Checks the real-time status (encoding, failed, complete) for one or more registered transcoding tasks.
Start Encode
Begins a specific transcoding job using defined parameters and the required session...
Start Live Stream
Initiates a live broadcast feed, starting the stream flow after setup is complete.
Stop Live Stream
Shuts down an active live broadcast feed gracefully and immediately.
Update Live Stream
Modifies existing live stream configurations, such as changing DVR settings or...
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token
from cloud.vinkius.com. For OAuth-protected servers, expand
Advanced settings to add credentials.
Start a conversation
Open a new chat. The Qencode integration is available immediately — no restart needed.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Qencode, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Qencode. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 11 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Setting up a live stream shouldn't feel like managing ten different dashboards.
Today, setting up a reliable multi-platform live feed means logging into your CDN dashboard to create a domain. Then you switch over to the streaming platform console to define the protocols (RTMP/WebRTC). After that, you open an entirely different window just to manage simulcasting targets for YouTube and Twitch manually.
With Qencode, you let your AI agent handle all those steps in sequence. You simply ask it to 'Set up a live feed.' The server executes `create_domain`, calls `create_live_stream` with the right protocols, and uses `add_simulcast_target`—all hidden behind simple tool calls.
Qencode MCP Server: Run full video ops from a chat window.
Instead of writing lengthy shell scripts or navigating between vendor-specific APIs, you just tell your agent what the final output should be. You don't worry about the sequence—the required tokens, the domain setup, or which tool runs first.
The server manages the state: it gets the token (`get_live_access_token`), creates the stream (`create_live_stream`), and then starts broadcasting. It’s a complete system handshake executed in one conversational flow.
What your AI can actually do with this
Qencode MCP Server: Full-Stack Video Management
Your AI client connects to Qencode for heavy-lifting video processing and live broadcasting. You don't touch a command line; your agent manages complex media pipelines—transcoding, setup, simulcasting—using nothing but natural conversation.
Getting Started & Infrastructure Prep
Before you do anything else, your agent needs credentials. It first grabs an access token for encoding jobs using get_access_token or gets a specific live stream token via get_live_access_token. For reliable content delivery, the system lets your agent create and register custom Content Delivery Network (CDN) domains with create_domain. This ensures where you're sending your video is solid.
Transcoding Jobs: Encoding Videos
The server handles creating and managing encoding tasks. You tell your agent to define a new job using create_task, specifying both the source file and all desired output formats in structured JSON. Once the task definition is locked down, you kick off the process with start_encode. The system keeps tabs on everything; if you need to know what's happening—whether it's encoding, failed, or complete—your agent checks the real-time status for multiple jobs using get_task_status.
Live Broadcast Setup and Control
Starting a live stream requires setup. You first establish a brand new instance of the broadcast feed using create_live_stream, specifying all required protocols like RTMP or WebRTC, along with necessary delivery formats such as HLS/CMAF. Once the infrastructure is ready, your agent initiates the flow with start_live_stream. If you need to tweak anything about an active stream—say, changing DVR settings or adjusting protocols—you modify those existing configurations using update_live_stream.
When you're done, your agent shuts it down cleanly and immediately with stop_live_stream.
Multi-Platform Simulcasting
This thing handles broadcasting everywhere at once. You can tell your agent to add multiple restreaming destinations—like Twitch and YouTube—to an already running stream using add_simulcast_target. This keeps your live feed active and visible across every platform simultaneously, all from one spot.
How It Works With Your Agent
Your AI client manages the entire sequence. When you say, "Set up a webinar broadcast," your agent understands it needs to first get the proper token, then maybe create a CDN domain if none exists, define the stream parameters, start the feed, and finally configure all the required restreaming targets—all without you ever touching the terminal.
It's just talking to your AI client that handles the whole damn media pipeline.
019ea600-1d84-7074-a3d5-63128fb76882 
Here's how it actually works
The bottom line is that Qencode handles the entire media pipeline—from authentication and infrastructure setup to task execution and status reporting—all through tool calls.
First, your AI client must call get_live_access_token or get_access_token to retrieve the necessary session key.
Next, you tell your agent the objective—for example, 'Create a stream' or 'Encode this video.' The agent then executes setup tools (create_domain, create_live_stream).
Finally, once everything is configured and tokens are acquired, the agent runs the action tool (e.g., start_live_stream or start_encode) to execute your request.
Who is this actually for?
Anyone running a content platform or video archive hits roadblocks managing transcoding and live feeds. This server is for the Video Engineer tired of chaining together shell scripts, the Content Platform Manager who needs to programmatically manage simulcasting targets, and the Product Team that needs status checks integrated into non-video tools.
Manages complex transcoding workflows. They use this server to automate batch encoding runs and monitor task queues without leaving their primary editor or terminal.
Orchestrates live streaming infrastructure for multiple events. They set up new streams, manage simulcast targets (like YouTube/Twitch), and update delivery settings programmatically.
Integrates video processing status checks into deployment pipelines or monitoring dashboards, using tools like get_task_status to confirm job completion before proceeding.
What Changes When You Connect
Streamline multi-platform delivery. Use add_simulcast_target to automatically push a single live feed to multiple services (like YouTube, Twitch) instantly.
Manage complex media workflows from chat. You can initiate encoding runs with create_task and start them with start_encode, all without ever touching the CLI.
Never lose track of jobs. Check real-time progress on batches of videos using get_task_status. The server tracks downloading, encoding, and saving status for you.
Build reliable infrastructure fast. Use create_domain to provision custom CDN domains before setting up a stream, ensuring your audience always gets the content they expect.
Full lifecycle control. Start with create_live_stream, update settings with update_live_stream, and wrap it all up cleanly using stop_live_stream.
See it in action
Running a multi-channel corporate webinar
The Content Platform Manager needs to broadcast a single event simultaneously on YouTube, Vimeo, and the company intranet. They use create_live_stream for setup, then call add_simulcast_target three times—once for each platform—to ensure perfect redundancy and coverage.
Processing a large video archive nightly
The Video Engineer has hundreds of raw videos that need to be converted from MOV to MP4, HLS, and WebM. They call create_task for each file and then loop through start_encode, using get_task_status hourly until everything shows 'completed'.
Setting up a temporary live stream quickly
A Product Team needs to run an emergency demo stream. They use the agent to first call create_live_stream, then get the necessary get_live_access_token. Finally, they execute start_live_stream in under five steps.
Updating broadcast delivery settings mid-event
During a live stream, the Content Manager realizes the DVR window needs to be extended. Instead of logging into the dashboard, they call update_live_stream, making the necessary configuration change programmatically while the feed stays active.
The honest tradeoffs
Manual token retrieval
The user manually runs multiple commands to get tokens, leading to a messy script that breaks when credentials expire.
Always start by letting your agent call get_live_access_token or get_access_token. This ensures you have the current, valid session key for all subsequent actions.
Ignoring infrastructure setup
Starting a live stream (start_live_stream) without first creating a custom CDN domain (create_domain) results in unreliable delivery and hard-to-diagnose errors.
Treat infrastructure tools as prerequisites. Always run create_domain before you attempt to set up or modify any live stream.
Single-platform streaming
Setting up a single feed for one platform when the content needs to be seen everywhere. This creates unnecessary operational risk if that one service fails.
Always use add_simulcast_target after creating your initial stream to automatically broadcast the same input across multiple services (YouTube, Twitch, etc.).
When It Fits, When It Doesn't
Use this server when your content delivery requires complex orchestration: multi-format transcoding, reliable custom CDN domains, or simultaneous broadcasting to more than one platform. If you only need to upload a single file and convert it once (e.g., MOV to MP4), a simple cloud storage API might be easier. However, if the video processing is part of a larger, automated pipeline—for example, 'Transcode this clip AND stream it live on two platforms'—this server manages the entire state machine for you. Don't use this if your only goal is to check a single file's size; that just needs basic file system access.
When in doubt, think about dependencies. Does Task B require Domain A? If so, create_domain must run first. The tool set forces you to handle the full lifecycle, which is exactly what complex media platforms need.
Questions you might have
How do I start encoding videos using the Qencode server? +
You must first call get_access_token to get your session key. Then, use create_task to define the source and output formats, followed by start_encode.
What's the difference between creating a live stream and starting it? +
create_live_stream only sets up the infrastructure—it reserves the slot on the platform. You must call start_live_stream afterward to actually begin sending video data.
Can I connect my own custom CDN domain? +
Yes, you use the create_domain tool to provision and manage your custom CDN domains within the Qencode ecosystem.
What should I do if a simulcast target fails? +
You can check the status of all running tasks using get_task_status. This helps you pinpoint whether the failure is in the encoding step or the delivery step.
What is required before using the `create_task` tool? +
You must first call the get_access_token tool. This establishes a session-based token that your AI agent uses to authenticate all subsequent encoding commands and manage resources.
How does the `get_task_status` tool report transcoding progress? +
It provides a real-time status for one or more tasks. The output includes the current stage (like 'encoding' or 'downloading') and a percentage complete, letting your agent track progress across multiple task IDs.
Can I change live stream settings after calling `create_live_stream`? +
Yes, you use the update_live_stream tool. This function lets you adjust configurations—like DVR settings or output protocols—without needing to delete and recreate the entire broadcast setup.
If I need to shut down a live session, how do I use `stop_live_stream`? +
Running the stop_live_stream tool immediately ends the active broadcast feed. This ensures resources are released cleanly and prevents continued streaming until you manually start it again.
How can I check if my video is finished encoding? +
Use the get_task_status tool with your task tokens. It returns the current state such as 'downloading', 'encoding', 'saving', or 'completed' for one or more tasks.
Can I stream to multiple platforms like YouTube and Twitch at once? +
Yes! First create a stream with create_live_stream, then use add_simulcast_target to add external destinations to your live feed.
Do I need to get an access token before every transcoding task? +
Yes, you must call get_access_token to receive a session-based token required by the create_task tool. For live streaming, use get_live_access_token instead.
We've already built the connector for Qencode. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 11 tools are live and waiting.
You're up and running in seconds.
Gemini Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.