Qencode MCP for AI. Run your entire video pipeline from a single chat window.

Q: How do I check if my transcoding job worked using gettaskstatus?

You pass the task ID(s) to gettaskstatus. The response tells you exactly what state it's in: 'downloading', 'encoding', or 'completed'. It’s great for debugging failed jobs too.

Q: What do I need before running startlivestream?

You first must call getliveaccesstoken to get the session key. Then you run createlivestream to define the feed, and only after that can you use startlivestream.

Q: Can I update stream settings without stopping the feed? Use updatelivestream.

Yes. The updatelivestream tool lets you modify things like DVR retention or keys while the broadcast is active, minimizing downtime and complexity.

Q: How do I get a session-based access token using getaccesstoken?

You must call getaccesstoken first to generate the necessary API credentials. These tokens are session-based and required before you can use tools like createtask or startencode.

Q: What steps are needed to set up a new endpoint using createdomain?

Use createdomain to provision a unique, custom Content Delivery Network domain. This allows you to point your live streams or transcoded assets to your own branded URL instead of the default Qencode address.

Q: If I need to end a broadcast immediately, how does stoplivestream work?

Calling stoplivestream terminates the active live feed instantly. This tool ensures that you can gracefully shut down your stream without manually interfering with the infrastructure setup or requiring an external client disconnect.

Claude

ChatGPT

Cursor

Gemini

Windsurf

VS Code

JetBrains

Vercel

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Connect to your AI in seconds.

Qencode MCP Server automates high-performance video processing and live broadcasting. Connect your Qencode account to manage complex workflows—from initiating transcodes via `create_task` to setting up multi-target simulcasts with tools like `add_simulcast_target`.

Your AI agent handles the whole pipeline, letting you monitor status, start streams, and update infrastructure directly from chat.

What your AI can do

Add simulcast target

Adds a secondary streaming destination (like Twitch or YouTube) to an already active live stream.

Create domain

Creates and reserves a custom Content Delivery Network (CDN) domain name for your video assets.

Create live stream

Initializes and defines the settings for an entirely new live broadcast feed using specific protocols.

+ 8 more capabilities included

Start Transcoding Jobs

The agent initializes video encoding tasks by accepting source/output parameters, creating a job ID for later monitoring.

Manage Live Streams

You can create new live feeds (using protocols like RTMP or WebRTC), start them up, and stop them when done.

Scale Broadcasts

The agent adds restreaming targets—like YouTube or Twitch—to an active stream so the content broadcasts to multiple places instantly.

Monitor Progress

You track the real-time status of any encoding task, seeing if it's downloading, encoding, or finished.

Configure Domains

The agent provisions and manages custom CDN domains needed for reliable video delivery.

Ask an AI about this

Included with Plan

Waiting for input…

AI Agent

Qencode: 11 Tools for Advanced Video Operations

These eleven tools let your agent handle everything from getting API tokens and setting up custom CDN domains to starting, managing, and scaling 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 Vinkius

Add Simulcast Target

Adds a secondary streaming destination (like Twitch or YouTube) to an already active live stream.

Create Domain

Creates and reserves a custom Content Delivery Network (CDN) domain name for your...

Create Live Stream

Initializes and defines the settings for an entirely new live broadcast feed using...

Create Task

Creates a background job to transcode one or more source videos into different...

Get Access Token

Retrieves the temporary session token required before any video transcoding task can...

Get Live Access Token

Gets a specific, short-lived access key needed to start or manage live streaming sessions.

Get Task Status

Checks the current progress and final status of one or more running transcoding jobs using their unique IDs.

Start Encode

Kicks off a defined transcoding job, beginning the actual process of converting...

Start Live Stream

Activates the live stream session after it has been successfully created and...

Stop Live Stream

Terminates an active live broadcast feed, ending the streaming connection gracefully.

Update Live Stream

Modifies existing live stream settings—things like changing DVR retention 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.

Antigravity

Configure Agent Environment

Open your Antigravity agent's workspace configuration or mcp-servers.json file.

Bind the Endpoint

Add the Vinkius endpoint URL to your agent's MCP connections list:

"mcp_servers": {
  "qencode-alternative": {
    "serverUrl": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
  }
}

Provide your secure token in place of [YOUR_TOKEN_HERE] to ensure your agent requests are authenticated.

Execute

Start your Antigravity session. The agent will autonomously discover and utilize the Qencode tools with full Vinkius guardrails applied.

VS Code Copilot

⚡

One-Click Install (Recommended)

In your Vinkius Dashboard, simply click the Add to VS Code button for this server. We'll automatically configure your local workspace.

Or configure manually

Open MCP Settings

Open VS Code, press Ctrl/Cmd + Shift + P, and search for GitHub Copilot: MCP Servers.

Add Server Config

Add the Vinkius endpoint configuration to your mcp-servers.json file:

"qencode-alternative": {
  "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
}

Ensure you replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.

LangChain

Install Dependencies

Install the LangChain MCP adapters for your environment:

pip install langchain-mcp-adapters

Connect the Server

Use the SSEClient in LangChain to connect to the Vinkius managed endpoint:

from langchain_mcp_adapters.client import SSEClient

# Connect to Vinkius
client = SSEClient(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")
tools = client.get_tools()

CrewAI

Define the Tool

Load the Vinkius MCP tools into your CrewAI agents:

from crewai import Agent
from mcp_crewai import MCPTool

# Connect securely to Vinkius
vinkius_tools = MCPTool(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")

# Assign to Agent
researcher = Agent(
    role='Data Researcher',
    tools=vinkius_tools.get_all()
)

Execute Task

Run your CrewAI process. The agent will autonomously route tasks to the Vinkius managed server.

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

Start building

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

Your data is protected. See how we built it.

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.

Managing live streams means jumping between four different dashboards.

Right now, starting a single multi-target broadcast is a pain. You have to jump into your streaming dashboard to create the stream (`create_live_stream`). Then you open your CDN console to manage domains (`create_domain`), and finally, you check a different tool just to add secondary targets like Twitch or YouTube using `add_simulcast_target`. It's a whole mess of tabs.

With this MCP server, the flow changes. You tell your agent: 'Get me live on three platforms.' The agent handles getting the tokens, creating the stream, and adding all simulcasts automatically. You just get confirmation that it's running.

Qencode MCP Server: Run video ops from chat.

The manual steps—obtaining access keys, creating the initial job ID, then separately starting the encoding process—all vanish. The agent sequences these calls for you using `get_access_token`, followed by `create_task` and `start_encode`. It's a single conversation.

Your workflow is now defined by your chat input. You stop thinking about API calls and start focusing on the content itself.

Support 24/7 support@vinkius.com ↗

Security Vinkius Trust Center ↗

SLA Service Level Agreement ↗

Report Listing Send Report ↗

What your AI can actually do with this

Qencode MCP Server automates high-performance video processing and live broadcasting right through your chat interface. You don't have to juggle multiple dashboards or run complicated command lines; your AI agent handles the entire workflow—from encoding big files to setting up multi-location simulcasts.

When you use this server, your agent manages everything in one place: transcoding jobs, complex live streams, and infrastructure setup. It’s built for people who need reliable video delivery that scales fast.

Starting the Process: Transcoding Videos

If you gotta convert source videos into different formats, you'll start by getting an access token using get_access_token. Once you have that key, you create a background job with create_task, defining exactly what sources and outputs you need. After the task is created, you kick off the actual conversion process by calling start_encode.

You never forget where you left off because you can check the real-time progress of any running encoding job using its unique ID with get_task_status. This whole setup lets you manage massive batches of video files without ever leaving your chat.

Running a Live Stream

To go live, you first pull a temporary access key specific to streaming by calling get_live_access_token. Next, you define the entire stream using protocols like RTMP or WebRTC with create_live_stream, setting up all your initial parameters. Once everything's configured and ready to rock, you activate the feed with start_live_stream. When the broadcast is done, you terminate it cleanly using stop_live_stream.

You can also fine-tune what’s happening during the stream; use update_live_stream if you need to change things like DVR retention settings or update encryption keys while the feed is running.

Scaling and Infrastructure

If one destination isn't enough, you gotta broadcast everywhere. If you want your content available on Twitch or YouTube simultaneously with your main stream, you use add_simulcast_target to send the signal to secondary destinations automatically. For rock-solid delivery, you can reserve a custom Content Delivery Network (CDN) domain name for all your video assets by calling create_domain.

This gives you reliable endpoints for global distribution.

Your AI client handles this whole pipeline—it doesn't just run commands; it tracks the status of every task, manages credentials, and updates infrastructure settings using a single conversation thread. You get maximum control over your entire video lifecycle without touching a separate dashboard.

Built · Hosted · Managed by Vinkius Qencode MCP Server - Video Transcoding & Live Streaming API

Server ID 019ea600-4c38-7363-bc3b-e7407bb14c4e

Vinkius Inspector

Compliance Grade A+

Score 100/100

Report View Report ↗

Here's how it actually works

The bottom line is that instead of running commands sequentially in a terminal, you talk to your AI client, and it sequences all the necessary API calls for you.

First, your AI client calls get_access_token (or get_live_access_token) to grab the necessary session key.

Next, you use that key with a creation tool—like create_task or create_live_stream—to define the stream parameters and launch the setup.

Finally, your agent executes the action (start_encode, start_live_stream) and confirms the operation's status, giving you immediate confirmation.

Who is this actually for?

This server is built for video engineers and content platform architects. If you're the person tired of switching between encoding dashboards, CDN consoles, and streaming tools just to run a single broadcast, this is for you. It lets you treat your entire media infrastructure like a chat conversation.

Video Engineer

Uses get_task_status and start_encode to automate complex transcoding pipelines without leaving their development environment.

Broadcast Producer

Manages multiple simulcast targets using add_simulcast_target so a single live feed hits YouTube, Twitch, and internal players at once.

Platform Architect

Uses create_domain and update_live_stream to manage and configure the underlying CDN infrastructure programmatically.

What Changes When You Connect

Transcoding doesn't wait. Use start_encode to kick off complex jobs, and then check the real-time progress with get_task_status. You never have to leave your editor just to monitor task completion.

Scale live broadcasts instantly. After running add_simulcast_target, your single stream automatically hits YouTube, Twitch, and any other target you need. No manual setup required for every platform.

Manage infrastructure without logging in. Use create_domain or update_live_stream to set up CDN endpoints or adjust DVR settings directly via a simple conversational prompt.

It’s all about the keys. Your AI agent handles getting the necessary session tokens first—using get_access_token and get_live_access_token—before it attempts any action, preventing failed calls.

The full lifecycle is covered. You can use create_live_stream, then start_live_stream, and finally stop_live_stream. It’s a complete control loop for your broadcast.

See it in action

01 01

Emergency Multi-Platform Broadcast

The platform architect needs to start an emergency live webinar. Instead of logging into three separate services, they ask their agent: 'Start a new stream named Beta with RTMP input.' The agent calls create_live_stream and start_live_stream. Then, it immediately runs add_simulcast_target for both YouTube and LinkedIn to ensure maximum reach.

02 02

Automated VOD Prep

A video team finishes a raw recording. They prompt their agent: 'Transcode this file into 1080p MP4, 720p WebM, and generate thumbnails.' The agent calls create_task, waits for the token via get_access_token, then uses start_encode. They track progress until all formats are done using get_task_status.

03 03

CDN Migration

The Ops Engineer needs to switch their primary CDN endpoint. Instead of updating configuration files manually, they tell the agent: 'Change our default domain.' The agent uses create_domain to provision and update the necessary endpoints via update_live_stream.

04 04

Stream Maintenance

The broadcast needs a minor setting change (like increasing DVR retention). Rather than finding the specific panel in the dashboard, the engineer asks: 'Increase the stream's recorded history to 7 days.' The agent runs update_live_stream immediately.

The honest tradeoffs

Assuming persistence

Anti-pattern

A user tries to start a task using start_encode() without first calling get_access_token(). This fails because the API needs an active session key.

The Fix

Always run get_access_token first. The agent uses that token internally before running create_task and then start_encode to ensure everything works.

Overcomplicating stream setup

Anti-pattern

Trying to manually configure protocols for every single target (e.g., setting up RTMP, HLS, and SRT targets individually). This takes hours.

The Fix

Use create_live_stream once to define the core feed, then use add_simulcast_target to hook up all required endpoints automatically.

Ignoring status checks

Anti-pattern

Calling start_encode and assuming the job started immediately without checking. The user doesn't know if the source file is valid or if there are quota limits.

The Fix

After calling create_task, always follow up with get_task_status. This confirms the job was accepted by Qencode and gives you immediate feedback on its state.

When It Fits, When It Doesn't

Use this server if your core pain point is managing a complex, multi-stage video lifecycle (transcode -> stream -> scale). You need one place to manage everything from CDN setup (create_domain) to real-time streaming control (start_live_stream).

Don't use it if you only need basic file storage or single-protocol encoding. If your job is simple—like just uploading a video and having it converted once—you might be better off with simpler cloud services that don't require the full orchestration layer. This server shines when multiple, interconnected actions must happen in sequence: Get Token -> Create Task -> Start Encode -> Check Status.

Questions you might have

How do I check if my transcoding job worked using get_task_status? +

You pass the task ID(s) to get_task_status. The response tells you exactly what state it's in: 'downloading', 'encoding', or 'completed'. It’s great for debugging failed jobs too.

What do I need before running start_live_stream? +

You first must call get_live_access_token to get the session key. Then you run create_live_stream to define the feed, and only after that can you use start_live_stream.

How many targets can I add with add_simulcast_target? +

It adds one target per call. If you need multiple platforms (like YouTube and Twitch), you'll just run the add_simulcast_target tool once for each service.

Can I update stream settings without stopping the feed? Use update_live_stream. +

Yes. The update_live_stream tool lets you modify things like DVR retention or keys while the broadcast is active, minimizing downtime and complexity.

How do I get a session-based access token using get_access_token? +

You must call get_access_token first to generate the necessary API credentials. These tokens are session-based and required before you can use tools like create_task or start_encode.

What steps are needed to set up a new endpoint using create_domain? +

Use create_domain to provision a unique, custom Content Delivery Network domain. This allows you to point your live streams or transcoded assets to your own branded URL instead of the default Qencode address.

What specific JSON data must I pass to start_encode? +

You provide a JSON payload detailing the source, output format, and encoding parameters. The tool uses these explicit instructions to begin the transcoding process immediately after you have created a task.

If I need to end a broadcast immediately, how does stop_live_stream work? +

Calling stop_live_stream terminates the active live feed instantly. This tool ensures that you can gracefully shut down your stream without manually interfering with the infrastructure setup or requiring an external client disconnect.

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.

Connect to your AI in seconds.

Add simulcast target

Create domain

Create live stream

Qencode: 11 Tools for Advanced Video Operations

Make your AI actually useful.

Add Simulcast Target

Create Domain

Create Live Stream

Create Task

Get Access Token

Get Live Access Token

Get Task Status

Start Encode

Start Live Stream

Stop Live Stream

Update Live Stream

Security and governance baked right in.

Claude AI

Open Claude Settings

Add Custom Connector

Start a conversation

Claude Code

Open your terminal

Add the MCP Server

Start coding

Cursor

One-Click Install (Recommended)

Open Cursor Settings

Add New Server

Use in Composer

Antigravity

Configure Agent Environment

Bind the Endpoint

Execute

VS Code Copilot

One-Click Install (Recommended)

Open MCP Settings

Add Server Config

Windsurf

One-Click Install (Recommended)

Open Windsurf Settings

Add Server Endpoint

LangChain

Install Dependencies

Connect the Server

CrewAI

Define the Tool

Execute Task

Choose How to Get Started

Build Your Own

Make Your AI Do More

Works with Claude, ChatGPT, Cursor, and more

Managing live streams means jumping between four different dashboards.

Qencode MCP Server: Run video ops from chat.

What your AI can actually do with this

Here's how it actually works

Who is this actually for?

What Changes When You Connect

See it in action

Emergency Multi-Platform Broadcast

Automated VOD Prep

CDN Migration

Stream Maintenance

The honest tradeoffs

Assuming persistence

Overcomplicating stream setup

Ignoring status checks

When It Fits, When It Doesn't

Questions you might have