AI Video Check MCP Server
Allows checking videos at public Facebook links for AI-generation probability, returning separate picture and sound scores.
Allows checking videos at public Instagram links for AI-generation probability, returning separate picture and sound scores.
Allows checking videos at public TikTok links for AI-generation probability, returning separate picture and sound scores.
Allows checking videos at public YouTube links for AI-generation probability, returning separate picture and sound scores.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@AI Video Check MCP Servercheck if this video is AI-generated: https://youtu.be/dQw4w9WgXcQ"
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.
AI Video Check — MCP server
Let Claude, Cursor or any MCP client check whether a video was generated by AI.
This server connects your AI assistant to AI Video Check, a detector for AI-generated video (Sora, Veo, Kling, MiniMax, HeyGen and others). Give it a link or a local file, and it returns the probability of AI generation with separate scores for the picture and the sound.
It is a thin layer over the public AI Video Check API: the same key, the same credits and the same results.
Tools
Tool | What it does | Cost |
| Checks the video at a public link (TikTok, Instagram, X, YouTube, Facebook or a direct file URL). Waits up to about a minute for the result. | 1 credit per started minute of video |
| Returns the result of an earlier check. Results are kept for 24 hours. | free |
| Shows the remaining credits and the limits of your key. | free |
| Checks a video file on your own computer. Local mode only. | 1 credit per started minute of video |
Every result tells the assistant how to read it: a probability, not proof. A low score means no signs of generation were found, not that the video is authentic. Editing, visual effects and face swaps on real footage are not detected.
Related MCP server: uploadcheck
Get a key
Sign in at aivideocheck.net and confirm your e-mail.
Open Dashboard → API and create a key. It is shown once.
Your first key comes with 20 free credits for the API.
Keep the key secret. Anyone holding it spends your credits. You can revoke a key on the same page; it stops working within a minute.
Connect: remote server (links)
The server runs at https://api.aivideocheck.net/mcp (Streamable HTTP). Your client sends the key in the Authorization header.
Claude Code
claude mcp add --transport http aivideocheck https://api.aivideocheck.net/mcp --header "Authorization: Bearer avc_live_..."Cursor (~/.cursor/mcp.json)
{
"mcpServers": {
"aivideocheck": {
"url": "https://api.aivideocheck.net/mcp",
"headers": { "Authorization": "Bearer avc_live_..." }
}
}
}Any other client that supports Streamable HTTP with custom headers works the same way.
Connect: local server (links and files on your computer)
The local server runs on your machine and can also check video files from your disk. It uploads them to AI Video Check for analysis, exactly as the website does; files are deleted when the check ends.
git clone https://github.com/aivideocheck/aivideocheck-mcp
cd aivideocheck-mcp
python -m venv .venv
.venv/bin/pip install -r requirements.txt # Windows: .venv\Scripts\pipThen point your client at it, for example Claude Desktop (claude_desktop_config.json):
{
"mcpServers": {
"aivideocheck": {
"command": "/path/to/aivideocheck-mcp/.venv/bin/python",
"args": ["/path/to/aivideocheck-mcp/avc_mcp.py"],
"env": { "AVC_API_KEY": "avc_live_..." }
}
}
}check_file sends only files that are named and built like a video container (MP4, MOV, WebM, MKV, AVI and similar). Anything else stays on your computer, so an instruction hidden in a web page cannot make your assistant upload, say, your SSH key.
Configuration
Variable | Default | Meaning |
| — | Your key. Read in local mode only; the remote server never uses a key from its own environment. |
|
| API address. |
|
| How long |
Development
.venv/bin/python tests/test_mcp.pyThe test runs the server against a fake API on 127.0.0.1, over real HTTP and real stdio, with the MCP SDK's own client. It does not touch the live service.
Pricing and terms
Checks spend the same credits as the website: one credit per started minute of video. Prices are on the developer page. Use of the API is governed by the Terms of Service and the Privacy Policy.
Questions: support@aivideocheck.net
License
MIT — see LICENSE.
Available Tools
4 toolscheck_fileCheck a video fileAInspect
Check whether a video file on this computer was generated by AI. Uploading the original file gives a more reliable result than a link. Spends credits: one per started minute of video.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With annotations present (readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false), the bar is lower, and the description adds real value: the credit cost ('one per started minute of video') and the reliability tradeoff between file and link. It does not mention supported formats or upload limits, but the cost disclosure is meaningful behavior not captured anywhere else.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, front-loaded with the core purpose, then the input-quality hint, then the cost. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values needn't be described. The description covers purpose, input preference, and cost — enough for an agent to select and invoke the tool — though format/size constraints on the local file are left unstated.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the single required 'path' parameter has no documented semantics. The phrase 'a video file on this computer' hints that path is a local filesystem path, but there is no format, extension, or size guidance, so the description only partially compensates for the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: check whether a video file on this computer was AI-generated. It implicitly contrasts with check_video by noting that uploading the original file is more reliable than a link, but it never names the sibling, so differentiation is inferential rather than explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It guides input choice ('uploading the original file gives a more reliable result than a link') but never says when to call check_file versus check_video, get_check, or get_balance, nor any prerequisite conditions. Usage is implied by the input-type contrast rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
check_videoCheck a video by linkAInspect
Check whether the video at a public link (TikTok, Instagram, X, YouTube, Facebook or a direct file URL) was generated by AI. Spends credits: one per started minute of video. Waits up to about a minute; if the check is not done by then, returns its id for get_check.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With annotations covering safety flags, the description still adds high-value operational context: credit cost (one per started minute), an expected latency bound (~1 minute), and the async continuation behavior of returning an id. These are exactly the traits an agent needs to plan a call.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, front-loaded with the purpose, then cost and latency, then the fallback. Every sentence carries distinct information with no padding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists so return values need not be described, and the description still covers cost, timing, and the failure/continuation path. Nothing an agent needs to invoke it correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only one parameter with 0% schema description coverage, so the description must carry the load — and it does, specifying that the url must be a public link and listing the supported platforms plus direct file URLs. It could still clarify format/validation, hence not a 5.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource ('Check whether the video... was generated by AI') and enumerates the accepted sources (TikTok, Instagram, X, YouTube, Facebook, direct file URL), which makes it easy to distinguish from the sibling check_file.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Clearly frames the use case (detect AI-generated video) and explicitly routes to the sibling get_check when the check has not finished in time, including the condition. It does not state when this tool should be avoided in favor of another, so it stops just short of full when/when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_balanceCredit balanceARead-onlyInspect
Show how many AI Video Check credits the account has left and the limits of its key. Free.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds a genuine behavioral fact not in the annotations ('Free' — no credit consumption) and says both balance and key limits are returned, but says nothing about auth requirements or failure modes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the resource and payload, and the trailing 'Free.' is a compact high-value signal about cost. Nothing is padded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, return-value details are legitimately omitted, and a zero-param read tool needs little else. The only minor gap is that no prerequisite (e.g., key validity) or error condition is mentioned.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No parameter syntax or semantics are needed or missing.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (Show) plus the exact resource returned: remaining AI Video Check credits and key limits. It is unmistakably not a content-checking tool, cleanly separating it from the check_video/get_check/check_file siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The word 'Free' implies the agent can call this without spending credits, which is useful context, but there is no explicit when-to-use framing or note on prerequisites. Since no sibling offers an overlapping capability, the implicit guidance is adequate but thin.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_checkGet a check resultARead-onlyInspect
Get the status or result of an earlier check by its id. Free. Results are kept for 24 hours.
| Name | Required | Description | Default |
|---|---|---|---|
| check_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds two genuinely useful traits not in structured data: the call is free, and results expire after 24 hours — the latter materially affects retry/fallback behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, zero filler, with the core purpose front-loaded. Each sentence (purpose, cost, retention) earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, the description needn't explain return values, and it covers the key operational facts (cost, 24-hour retention, id-based lookup). Only the parameter's format and expiry failure mode remain undocumented.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one parameter with 0% description coverage, so the description must carry the load. 'By its id' identifies the parameter as a check identifier but adds no format, source, or example; for a single-param tool this is minimal-but-adequate rather than compensating for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource ('Get the status or result of an earlier check') and scopes it via 'by its id', so an agent knows this is a retrieval, not an initiation. It does not name the initiating siblings (check_video, check_file), so sibling differentiation is only implied by the word 'earlier'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Of an earlier check' implies the tool is used after a check has been kicked off, which is useful contextual guidance. It stops short of explicitly saying when to use this versus the check_* siblings or what to do if the id is unknown/expired.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
v1.0.0- First observed
check_file - First observed
check_video - First observed
get_balance - First observed
get_check
TDQS
Scored across 4 tools
check_video and check_file both detect AI-generated video and differ only by input source (public link vs local file), which the descriptions make clear but still requires reading carefully. get_check and get_balance have clearly distinct roles (retrieve result vs account status), so overlap is limited to the two check tools.
All four names follow a strict verb_noun snake_case pattern (check_video, check_file, get_check, get_balance). The verbs are used coherently: check_ for initiating analysis, get_ for retrieving information.
Four tools is well-scoped for a focused detection service: two submission paths, one result retrieval, and one account query. Every tool earns its place with no redundancy or padding.
The submit/retrieve/balance lifecycle is covered, including both URL and file inputs. Minor gaps exist: no way to list or cancel prior checks, and results expire after 24 hours without a cleanup or history operation.
Maintenance
Related MCP Connectors
Plan, compare, price, generate, and recover AI video from compatible MCP clients.
Create and manage AI image and video generations through Quriov's fixed public MCP tools.
Multimodal video analysis MCP — transcription, vision, and OCR for any video URL.
Hosted MCP tools for FFmpeg-style video and audio processing through FFMPEG API.
Related MCP Servers
AlicenseAqualityDmaintenanceEnables video enhancement through MCP tools for creating tasks, querying status, and synchronous enhancement, supporting URL or local file inputs.342 npmApache 2.0- AlicenseNot gradedqualityCmaintenanceThin MCP wrapper over the hosted UploadCheck API to quality check videos, podcasts, and clips before upload.47 npmMIT

video-analyzerofficial
FlicenseNot gradedqualityDmaintenanceMCP server enabling video analysis via scene detection, audio transcription, visual description, and stylistic fingerprinting, with tools for full pipeline execution and storyboard generation.-- FlicenseNot gradedqualityBmaintenanceEnables AI clients like Claude and ChatGPT to generate images and videos, animate images, create lip-synced videos, list TTS voices, and manage media via remote MCP tools.-