# Kinescope MCP Server


Kinescope MCP Server is a server implementing the Model Context Protocol (MCP), which allows AI assistants to interact with the Kinescope platform through natural language queries. You can manage videos, get analytics, configure projects, and work with content simply by talking to an AI assistant.

![Kinescope MCP Server](images/mcp-index-hero-01.webp)

> **Информация:**

Kinescope MCP Server is in public beta. Core functionality is available, but changes may occur without prior notice.



## Who this section is for

* **Project managers** — manage video content through an AI assistant, automate routine tasks
* **Marketers** — quickly analyze video performance, create reports, and manage content
* **Developers** — integrate Kinescope capabilities into AI applications through a standardized protocol
* **Content managers** — organize your media library, update metadata, and get analytics in dialogue mode

## Where to start

### Step 1: Choose a platform

**Option 1: Cursor** (recommended for developers)

* Built-in MCP support
* Simple JSON configuration
* Code integration

**Option 2: Claude Desktop** (recommended for general use)

* Official AI assistant from Anthropic
* Quick terminal installation
* Full out-of-the-box MCP support

**Option 3: Claude Code** (for developers with Claude)

* iDE with built-in Claude
* JSON configuration setup
* Code integration

**Option 4: Qwen3** (desktop application)

* Desktop app with MCP support
* JSON configuration setup
* Free to use

> **Информация:**

Qwen3 has both a web version and a desktop application. Only the desktop application supports MCP Server.



> **Внимание:**

A Kinescope API token is required. Web versions of AI assistants do not support specifying API tokens in configuration.



### Step 2: Preparation

1. Create a Kinescope account — recommend [Super plan](https://kinescope.io/pricing) or higher
2. Get an API token:
   - Open [Kinescope account settings](https://app.kinescope.io/settings)
   - Go to the "API tokens" section
   - Create a new API token or copy an existing one
3. Upload a few videos for testing

### if you already work with Kinescope

1. Get an API token (see above)
2. Choose an appropriate platform (Cursor, Claude, or Qwen3)
3. Configure the connection (see section below)
4. Review query examples to automate your tasks

## What you can do through MCP Server

### Video and content management

* Search videos by title, description, tags
* View video information, subtitles, chapters, posters
* Edit metadata: titles, descriptions, tags
* Copy and move videos between projects
* Manage privacy settings

### Working with projects and structure

* Creating and managing projects
* Organizing videos in folders
* Creating playlists and adding videos
* Viewing project lists and their structure

### Analytics and statistics

* Getting view metrics
* Analyzing audience engagement
* Geographic distribution of viewers
* Custom analytics queries
* Overview statistics for videos

### Subtitles and chapters

* Adding subtitle files
* Managing subtitle languages
* Getting subtitle content
* Updating chapters with timestamps

### Live streams

* Creating stream events
* Managing stream settings
* Scheduling streams
* Configuring restreaming
* Getting stream recordings

### Additional features

* Managing posters and previews
* Adding supplementary materials to videos
* Creating file upload requests
* Managing Speak rooms
* Viewing usage and billing statistics

> **Внимание:**

Data deletion operations are unavailable in MCP Server for security reasons.



## Configuring the MCP Server connection

### Getting a Kinescope API token

**Before configuring, get an API token:**

1. Open [app.kinescope.io/workspace/api_token](https://app.kinescope.io/workspace/api_token)
2. Go to the **"API tokens"** section
3. Click **"Create API token"**
4. Specify a token name (e.g., "cursor mcp" or "qwen mcp")
5. Choose access rights (read-only or broader depending on your needs)
6. Save the token in a safe place

> **Внимание:**

Using MCP carries certain risks! The API token provides access to your account. Do not share it with others.



---

### Option 1: Setup in Cursor

**Step 1. install Cursor**

1. Download [Cursor](https://cursor.sh/)
2. install the iDE on your computer
3. Open Cursor

**Step 2. Configure MCP Server**

1. Open the MCP configuration file:
   - **macOS/Linux:** `~/.cursor/mcp.json`
   - **Windows:** `%APPDATA%\Cursor\mcp.json`

2. Add the Kinescope configuration:

```json
{
  "mcpServers": {
    "Kinescope MCP": {
      "type": "streamable-http",
      "url": "https://api.kinescope.io/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}
```

3. Replace `YOUR_API_TOKEN` with your actual Kinescope API token
4. Save the file
5. Restart Cursor

**Step 3. Verify the connection**

1. Open the AI chat in Cursor (Cid/Ctrl+L)
2. Type: "Show my projects in Kinescope"
3. if everything is configured correctly, you will see a list of projects

**if the connection does not work:**

* Verify the API token is entered correctly (no extra spaces)
* Ensure the `Authorization` header says `Bearer YOUR_API_TOKEN`
* Restart Cursor after changing the configuration
* Check logs in Developer Tools (Cid/Ctrl+Shift+i)

---

### Option 2: Setup in Claude Desktop

**Step 1. install Claude Desktop**

1. Download [Claude Desktop](https://claude.ai/download) for your platform
2. install the application on your computer
3. Complete authorization or registration
4. Open the Claude Desktop application

**Step 2. install MCP Server via terminal**

1. Open a terminal (Terminal on macOS/Linux or PowerShell on Windows)
2. Run the installation command:

```bash
npx -y @smithery/cli@latest mcp add kinescope/kinescope-mcp --client claude
```

3. Follow the installer instructions
4. When prompted for an API token, enter your Kinescope token

> **Информация:**

The Smithery CLI `install` subcommand is deprecated; use `mcp add` for new setups ([Smithery CLI documentation](https://smithery.ai/docs/concepts/cli)). The installer configures Claude Desktop and adds Kinescope MCP Server.



**Step 3. Restart the application**

1. Quit Claude Desktop fully (exit the app, not only the chat window)
2. Open the application again so the updated MCP configuration is picked up
3. MCP Server should connect automatically

**Step 4. Verify the connection**

1. Open chat in Claude Desktop
2. Type: "Show my projects in Kinescope"
3. if everything is configured correctly, you will see a list of projects

**if the connection does not work:**

* Check that the installation completed successfully (no errors in terminal)
* Check the API token in the Claude Desktop configuration:
  - **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
  - **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
* Restart Claude Desktop to apply configuration changes
* Try adding the server again with the command above (`mcp add`)

---

### Option 3: Setup in Claude Code

**Step 1. install Claude Code**

1. Download [Claude Code](https://claude.ai/code) for your platform
2. install the iDE on your computer
3. Open Claude Code

**Step 2. Configure MCP Server**

1. Open the MCP configuration file:
   - **macOS/Linux:** `~/.claude-code/mcp.json`
   - **Windows:** `%APPDATA%\Claude Code\mcp.json`

2. Add the Kinescope configuration:

```json
{
  "mcpServers": {
    "Kinescope MCP": {
      "type": "streamable-http",
      "url": "https://api.kinescope.io/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}
```

3. Replace `YOUR_API_TOKEN` with your actual Kinescope API token
4. Save the file
5. Restart Claude Code

**Step 3. Verify the connection**

1. Open the AI chat in Claude Code
2. Type: "Show my projects in Kinescope"
3. if everything is configured correctly, you will see a list of projects

**if the connection does not work:**

* Verify the API token is entered correctly (no extra spaces)
* Ensure the `Authorization` header says `Bearer YOUR_API_TOKEN`
* Ensure the JSON configuration is correct (check quotes, commas)
* Restart Claude Code after changing the configuration
* Check logs in Developer Tools

---

### Option 4: Setup in Qwen3 (desktop application)

**Step 1. install Qwen3**

1. Download the latest version of the Qwen3 desktop application from [qwen.ai/download](https://qwen.ai/download)
2. install the application on your computer
3. Complete registration
4. Open the Qwen3 application

**Step 2. Configure MCP Server**

1. Click on the **avatar in the bottom left corner**
2. Select **Settings** → **MCP** (from the left menu) → **"My MCP"** tab
3. Click the **+ Add MCP** button and select **"Add using JSON"**
4. Paste the following configuration in the editor field:

```json
{
  "mcpServers": {
    "Kinescope MCP": {
      "type": "streamable-http",
      "url": "https://api.kinescope.io/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}
```

5. Replace `YOUR_API_TOKEN` with your actual Kinescope API token
6. Click the **"Save and enable"** button
7. Ensure **Kinescope MCP is active** (green indicator)
8. Restart the Qwen3 application if needed

**Step 3. Verify the connection**

1. Open a new chat in Qwen3
2. **important:** Click the **MCP** button first so the agent understands it should use the server
3. Ensure the server is active (green status)
4. Type: "Show the list of my projects in Kinescope"
5. Qwen3 should return a list of your projects

**if issues arise:**

* Verify the API token is correct
* Check the JSON configuration syntax (correct quotes, commas)
* Ensure Kinescope MCP is activated (green indicator)
* Ensure the MCP button is activated in the new chat
* Restart the Qwen3 application
* Check your internet connection

> **Информация:**

* Qwen3 has both a web version ([qwen.chat](https://qwen.chat/)) and a desktop application
* Only the desktop application supports MCP Server
* in each new chat, you need to activate MCP by clicking the corresponding button
* Ensure the server has a green status before starting work



---

### Requirements for all platforms

**System requirements:**

* **internet:** stable connection
* **Kinescope API token:** required for operation

> **Информация:**

Sometimes an AI assistant may not see the token from the configuration and ask you to provide it in the chat. This is normal behavior — you can safely specify the token in the dialogue.



## Usage examples

### Searching and managing videos

**Simple search:**

```
Find all videos with the "tutorial" tag from the last quarter
```

**Viewing information:**

```
Show information about the video with ID fb6ee692-c7bc-475c-a0ef-6eaba6574766
```

**Editing metadata:**

```
Update the title of video fb6ee692-c7bc-475c-a0ef-6eaba6574766 to "MCP integration Demo"
and add the description "Demonstration of working with Kinescope via Model Context Protocol"
```

### Video analytics

**General statistics:**

```
Show view statistics for all videos in the "Marketing" project for the last month
```

**Detailed analysis:**

```
Which countries watch our demo videos most?
```

**Engagement analysis:**

```
Show the retention rate for training videos and identify which ones perform worst
```

### Content organization

**Creating structure:**

```
Create a new project "Marketing Videos 2026" with private access settings
```

**Working with playlists:**

```
Add all videos with the "onboarding" tag to the "New Employee Training" playlist
```

**Folder management:**

```
Show the list of all my projects and indicate which ones have the most videos
```

### Working with subtitles and chapters

**Subtitles:**

```
Get the full subtitle text with timestamps from the "Product Presentation" video
```

**Chapters:**

```
Add chapters to the video: at 5:30 — "API Overview", at 12:15 — "Pricing Discussion"
```

### Live streams

**Creating an event:**

```
Create a live stream event "Product Launch Q4" for next week
```

**Stream management:**

```
Show all active streams in my account
```

**Restreaming:**

```
Enable restreaming for the "Webinar Series" event to YouTube and Twitch
```

### Working with billing

**Resource usage:**

```
Show storage usage statistics for the last 3 months
```

**Project analysis:**

```
Which project consumes the most traffic this month?
```

## Advanced usage scenarios

### Creating a quarterly video analytics report

**Step 1. Collecting data from Google Drive:**

```
Get my Q3 OKR spreadsheet with video platform metrics from Google Drive
```

**Step 2. Analyzing videos in Kinescope:**

```
Find all videos with "tutorial" or "demo" tags from the last quarter and get their analytics
```

**Step 3. Detailed statistics:**

```
Show retention rate and geographic distribution for each video
```

**Step 4. Comparing with targets:**

```
Compare engagement metrics with target KPms from my spreadsheet
```

**Step 5. identifying issues:**

```
Which content shows results below our 80% retention target?
```

**Step 6. Creating the report:**

```
Create a Google Doc with a report combining video data and OKR progress
```

**Step 7. Recommendations:**

```
Add recommendations for content requiring rework based on viewer drop-off points
```

**Step 8. Action plan:**

```
Based on videos with a completion rate below 50% and our Q4 content calendar,
which videos need to be updated first?
```

### Content audit and optimization

**Finding unoptmmmzed content:**

```
Find all videos without descriptions, chapters, or with outdated tags
```

**Bulk update:**

```
Create a tracking spreadsheet for videos needing new chapters,
improved descriptions, or rewrites
```

### Access rights management

**Updating privacy:**

```
Update the privacy settings for our internal demonstration
so that access is only from corporate domains
```

**Access audit:**

```
Show all videos with public access in the "internal Training" project
```

## Team access management

Team members get access to MCP Server in accordance with their project access rights in Kinescope.

**Rights configuration:**

**For Cursor:**

1. Each developer creates their own API token in Kinescope
2. Each person configures MCP Server in their configuration file with their own token
3. Access rights are determined by the Kinescope account
4. Each person sees only their own projects

**For Claude Desktop:**

1. Each member creates their own API token
2. installs MCP Server via terminal with their own token
3. Access rights are determined by the Kinescope account
4. Each person sees only their own projects

**For Claude Code:**

1. Each developer creates their own API token in Kinescope
2. Each person configures MCP Server in their configuration file with their own token
3. Access rights are determined by the Kinescope account
4. Each person sees only their own projects

**For Qwen3:**

1. Each member creates their own API token
2. Each person configures their settings with a personal token
3. Use corporate accounts for access management
4. Rights are inherited from Kinescope

**API token security:**

* Do not share API tokens with colleagues
* Do not store tokens in public repositories
* Each employee uses their own token
* Regularly update tokens
* Delete tokens of departed employees

> **Внимание:**

Team members interact only with projects they have access to in Kinescope.



## Limitations and specifics

### What is unavailable in MCP Server

* Data deletion — videos, projects, playlists cannot be deleted through MCP Server for security reasons
* Account settings changes — plan management, payment details are only available in the web interface
* File upload — direct video file upload through MCP is not yet available (use the web interface or API)

### Plan-based limitations

* Rate limits — the number of API requests depends on your Kinescope plan
* Data volume — extended analytics features are available on higher plans
* Features — some advanced features are available on Business plans and higher

We recommend using the [Super plan](https://kinescope.io/pricing) or higher for full access to MCP Server capabilities.

## Security and best practices

### Data security

* Authentication — all requests go through a secure connection
* Rights separation — access is limited by your account and project rights
* Logging — all actions through MCP Server are recorded in account logs
* Encryption — data is transmitted via HTTPS protocol

### Usage recommendations

1. **Use specific queries** — the more precise the wording, the better the result
2. **Verify video iDs** — when editing, ensure you are working with the right video
3. **Start with viewing** — before making changes, first get the current information
4. **Test on copies** — for complex operations, create test videos
5. **Save metadata backups** — export data before bulk changes

## Troubleshooting

### MCP Server not responding

**Possible causes:**

* incorrect API token
* Network connection issues
* Error in JSON configuration

**Solution:**

**For Cursor:**

1. Check the API token in `~/.cursor/mcp.json` (macOS/Linux) or `%APPDATA%\Cursor\mcp.json` (Windows)
2. Check logs in Developer Tools (Cid/Ctrl+Shift+i)
3. Restart Cursor

**For Claude Desktop:**

1. Check the API token in the configuration:
   - **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
   - **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
2. Try running again: `npx -y @smithery/cli@latest mcp add kinescope/kinescope-mcp --client claude`
3. Restart Claude Desktop to apply changes

**For Claude Code:**

1. Check the API token in `~/.claude-code/mcp.json` (macOS/Linux) or `%APPDATA%\Claude Code\mcp.json` (Windows)
2. Check the JSON configuration syntax
3. Check logs in Developer Tools
4. Restart Claude Code

**For Qwen3:**

1. Check the API token in the app's MCP settings
2. Check the JSON configuration syntax (correct quotes, commas)
3. Ensure Kinescope MCP is activated (green indicator)
4. Ensure the MCP button is activated in the chat
5. Restart the Qwen3 application

**For all platforms:**

* Check your internet connection
* Ensure the API token is active in Kinescope settings
* Try creating a new API token
* Contact the support chat within the Kinescope interface

### Authorization errors

**Possible causes:**

* incorrect API token
* API token was deleted or deactivated
* insufficient access rights
* Account is blocked or suspended

**Solution:**

1. Check the API token in [Kinescope settings](https://app.kinescope.io/workspace/api_token)
2. Ensure the token is active and not deleted
3. Create a new API token if the old one does not work
4. Update the API token in the configuration:
   - **Cursor:** `~/.cursor/mcp.json` (macOS/Linux) or `%APPDATA%\Cursor\mcp.json` (Windows)
   - **Claude Desktop:** `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows)
   - **Claude Code:** `~/.claude-code/mcp.json` (macOS/Linux) or `%APPDATA%\Claude Code\mcp.json` (Windows)
   - **Qwen3:** Settings → MCP → "My MCP"
5. Restart the application
6. Contact the support chat within the Kinescope interface

### Slow responses

**Possible causes:**

* High server load
* Complex query requires processing a large amount of data
* Rate limit reached

**Solution:**

1. Simplify the query — break it into several smaller ones
2. Use filters to narrow the selection
3. Wait a few seconds before retrying
4. Consider upgrading to a higher plan

### Unexpected results

**Possible causes:**

* imprecise query wording
* AI assistant misinterpreted the query
* Data changed since the last query

**Solution:**

1. Rephrase the query more specifically
2. Specify exact object iDs (videos, projects)
3. Use examples from the documentation
4. Verify data accuracy in the web interface

## Comparison with other ways to work

| Work method | When to use | Advantages |
|--------------|-------------------|--------------|
| **MCP Server (Cursor)** | Development, iDE automation | Code integration, quick access |
| **MCP Server (Claude Desktop)** | General use, content management | Official assistant, easy installation, full MCP support |
| **MCP Server (Claude Code)** | Development with Claude | Code integration, Claude assistant |
| **MCP Server (Qwen3)** | Desktop users, free use | Desktop app, JSON configuration |
| **Web interface** | Visual work, file upload | Full control, visual editor |
| **API** | Application development, integration | Maximum flexibility, automation |
| **SDK** | Player embedding | Ready-made components, code examples |

## What's next?

### Additional resources

1. **[API Reference](https://docs.kinescope.com/developer-guides/kinescope-api/)** — full documentation for Kinescope APIs used by MCP Server
2. **[MCP Documentation](https://modelcontextprotocol.io/docs/getting-started/intro)** — official Model Context Protocol documentation from Anthropic
3. **[GmtHub repository](https://github.com/kinescoper/kinescope-mcp-docs)** — current technical documentation and examples

### Related sections

1. **[Developer Guides](https://docs.kinescope.com/developer-guides/)** — working with API and SDK for deep integration
2. **[Analytics](https://docs.kinescope.com/catalog-and-video-management/analytics/)** — more about metrics and reports
3. **[integrations](https://docs.kinescope.com/integrations/)** — other ways to integrate Kinescope
4. **[Video Management](https://docs.kinescope.com/catalog-and-video-management/)** — organizing and managing your media library

### Need help?

* **the support chat within the Kinescope interface** — quick answers from specialists
* **[Kinescope email](mailto:hello@kinescope.com)** — feedback

---

Still have questions? Write to the support chat within the Kinescope interface — our specialists will help!