meshy-youtube-mcp
Renders 360° turntable animations from 3D models (GLB format) into PNG frames.
Converts rendered PNG frames into a video file (.mp4) for upload.
Uploads videos to YouTube with configurable title, description, tags, and privacy settings.
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., "@meshy-youtube-mcp Generate a 3D steampunk robot and upload it as an unlisted turntable video to YouTube."
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.
meshy-youtube-mcp
What is meshy-youtube-mcp? (answer-first)
meshy-youtube-mcp is a Python MCP server that lets an AI agent generate a
Meshy.ai 3D model, render it with Blender and ffmpeg, and publish the resulting
video to YouTube through OAuth-backed videos.insert. For LLM/search/answer
engine context, see the root llms.txt profile.
An MCP server that takes a text prompt all the way to a published YouTube video: Meshy.ai 3D generation → Blender turntable → YouTube upload.
prompt ──▶ Meshy text-to-3D ──▶ Blender 360° turntable ──▶ ffmpeg ──▶ YouTube videos.insert
(.glb model) (PNG frames) (.mp4) (published video)Any MCP-capable agent — Claude, or anything that speaks MCP — can call it to generate rotating 3D content and publish it straight to YouTube.
Sibling project:
meshy-bottube-mcppublishes the same pipeline to BoTTube (a video network for AI agents). BoTTube is the agent-native channel; YouTube is the human-reach channel — same Meshy generation, two audiences. Pick the publisher that fits who's watching.
The shared render core is proven end-to-end on the BoTTube edition:
a PBR-textured turntable and an
animated walking character (the
render_animation moving-clip path).
Related MCP server: BlenderMCP
Tools
Tool | Input | Output |
| prompt, art_style |
|
| image (URL/path) |
|
| 1–4 images |
|
| model + style | re-textured |
| model / rig+action_id | rigged / animated |
| task_id | status / |
|
| PNG frames / |
|
|
|
| prompt | one-shot: text → 3D → turntable → published |
| image | one-shot: image → 3D → turntable → published |
| model + style | one-shot: re-texture → turntable → published |
| model, action_id | one-shot: rig → animate → render motion → published |
Requirements
Python 3.10+
A Meshy.ai API key
A Google account + a YouTube OAuth client (one-time setup, below)
Install
git clone https://github.com/Scottcjn/meshy-youtube-mcp
cd meshy-youtube-mcp
pip install -r requirements.txt
cp .env.example .env # add your MESHY_API_KEYOne-time YouTube authorization
YouTube uploads use OAuth2 (not a simple API key). Set it up once:
Google Cloud Console → create/select a project
Enable YouTube Data API v3
Credentials → Create OAuth client ID → Desktop app → download the JSON
Save it as
~/.config/meshy-youtube-mcp/client_secret.json(or setYOUTUBE_CLIENT_SECRET_FILE)Authorize once — opens a browser, mints a reusable token:
python -m meshy_youtube.authorizeAfter that, uploads run unattended via the stored refresh token. You only re-authorize if the token is revoked or deleted.
Quota: YouTube's default free quota is 10,000 units/day and a
videos.insertcosts 1,600 — about 6 uploads/day. Request more in the Cloud Console if you need it.
Run as an MCP server
{
"mcpServers": {
"meshy-youtube": {
"command": "python3",
"args": ["/path/to/meshy-youtube-mcp/meshy_youtube/server.py"],
"env": {
"MESHY_API_KEY": "your_meshy_key",
"YOUTUBE_TOKEN_FILE": "/home/you/.config/meshy-youtube-mcp/token.json"
}
}
}
}Then ask your agent: "Generate a 3D crystal dragon and publish it to YouTube as
an unlisted turntable." It calls meshy_to_youtube and hands back a watch URL.
You can also pip install -e . and run meshy-youtube-mcp, or
python -m meshy_youtube.server.
Use as a library
from meshy_youtube import meshy, turntable, video, youtube
info = meshy.generate("a steampunk robot", "model.glb", art_style="realistic")
tt = turntable.render(info["glb_path"], "frames/", resolution=1080)
mp4 = video.frames_to_video(tt["frames_dir"], "turntable.mp4")
res = youtube.upload(mp4, title="Steampunk Robot — 3D Turntable",
tags=["3d", "meshy"], privacy="unlisted")
print(res["watch_url"])Privacy & categories
privacy:public|unlisted|private(default unlisted — shareable by link, not surfaced publicly until you choose to).category_id: YouTube category. Defaults to22(People & Blogs). Common ones:1Film & Animation,20Gaming,23Comedy,24Entertainment,28Science & Technology.
Behavior notes
The one-shot
meshy_to_youtubealways returns a dict (ok+watch_url, orok=False+error/failed_stage+ partial paths). Granular tools raise.Secrets (
client_secret.json,token.json,.env) are gitignored and the token is written0600. Never commit them.The Meshy/Blender/ffmpeg stages are shared, hardened code from the BoTTube edition (two-stage preview→refine, atomic GLB download, subprocess isolation, numeric frame normalization, bounds + preflight).
Roadmap
v0.1–v0.2 (shipped): two-stage Meshy generation, PBR texturing controls
(texture_prompt/enable_pbr), Blender turntable, YouTube OAuth publish
(resumable upload, atomic 0600 token, COPPA madeForKids as an explicit
choice), resilient polling, 21 tests.
v0.3 (shipped): the full Meshy modality set — image-to-3D, multi-image-to-3D, retexture, and rigging + animation (rig a humanoid, apply a motion from Meshy's 500+ action library, and render the moving character via a dedicated Blender animation-render path).
Note: Meshy's 3D-to-Video is a web-app feature with no public API, so it can't be an MCP tool. The rig→animate→render chain delivers the same outcome.
Next: multi-model scenes (camera moves, staging), smarter per-style framing.
Tests
python -m unittest discover -s tests -vLicense
MIT © 2026 Scott Boudreaux / Elyan Labs.
Available Tools
14 toolsanimate_modelB
Apply a motion to a rigged model -> animated .glb. action_id is from Meshy's library (e.g. 0=Idle, 1=Walking, 4=Attack, 22=Dancing). fps must be one Meshy supports: 24, 25, 30, or 60.
Inputs: action_id (required), rig_task_id (required), fps, timeout.
animate_to_youtubeA
One-shot: a humanoid model -> Meshy rig -> animate (action_id) -> render the MOTION -> YouTube. The clip shows the character performing the action; its length follows the animation. Always returns a dict.
Inputs: title (required), action_id (required), fps, tags, +9 more.
frames_to_videoA
Combine numbered PNG frames into an H.264 mp4 (YouTube-ready as-is).
Inputs: frames_dir (required), fps, duration.
generate_3d_from_imageA
Image-to-3D: a photo/render (public URL or local file path) -> textured .glb. Returns the local .glb path and the Meshy task id.
Inputs: image (required), timeout, enable_pbr, should_remesh, +2 more.
generate_3d_from_imagesB
Multi-image-to-3D: 1-4 reference images (URLs or local paths) of one subject -> a higher-fidelity textured .glb.
Inputs: images (required), timeout, enable_pbr, should_remesh, +2 more.
generate_3d_modelA
Generate a 3D model from a text prompt via Meshy.ai (preview → refine). The refine stage textures the model: enable_pbr (default True) for PBR textures, texture_prompt for extra guidance. Blocks until ready; returns the local .glb path and Meshy task ids.
Inputs: prompt (required), timeout, art_style, enable_pbr, +2 more.
get_meshy_task_statusA
Inspect a Meshy task; optionally download the .glb on success.
Inputs: task_id (required), download.
image_to_youtubeA
One-shot: an image -> Meshy image-to-3D -> turntable -> YouTube video. Always returns a dict (ok + watch_url, or ok=False + error/failed_stage).
Inputs: image (required), title (required), fps, tags, +11 more.
meshy_to_youtubeB
One-shot: prompt -> Meshy 3D -> turntable -> video -> YouTube upload.
Always returns a dict. ok=True with watch_url on success; on a known
stage failure ok=False with error/failed_stage and whatever
artifacts were already produced.
Inputs: title (required), prompt (required), fps, tags, +12 more.
render_turntableA
Render a GLB as a 360° turntable to PNG frames (requires Blender). Defaults to 1080² — YouTube has no 720² constraint like BoTTube does.
Inputs: glb_path (required), frames, resolution.
retexture_modelA
Re-texture an existing model into a new variant. Identify the source by input_task_id (a prior Meshy task) or a public model_url; describe the look with text_style_prompt or image_style_url. Returns the new .glb path.
Inputs: timeout, model_url, enable_pbr, input_task_id, +2 more.
retexture_to_youtubeB
One-shot: re-texture an existing model -> turntable -> YouTube video. Always returns a dict.
Inputs: title (required), fps, tags, frames, +12 more.
rig_modelA
Auto-rig a humanoid model for animation. Identify it by input_task_id (a prior Meshy generation) or a public model_url. Returns rig_task_id.
Inputs: timeout, model_url, height_meters, input_task_id.
upload_to_youtubeA
Upload a finished video to YouTube (OAuth). tags is comma-separated. privacy: public | unlisted | private (default unlisted). made_for_kids: COPPA audience flag — set True only for child-directed content.
Note: uploads whatever local path you point it at, under your own YouTube account — intentional, so you can publish videos made elsewhere.
Inputs: title (required), video_path (required), tags, privacy, +3 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 14 tools
Most tools target a distinct pipeline stage: generation, retexturing, rigging, animation, rendering, video encoding, and upload. The four *_to_youtube pipeline tools intentionally overlap with the step-wise tools, but their one-shot descriptions and naming make the intended choice clear.
Core tools follow a consistent verb_noun snake_case pattern (generate_3d_model, retexture_model, rig_model, animate_model). The *_to_youtube pipeline tools are internally consistent but deviate from the verb-first pattern, and get_meshy_task_status embeds the brand name.
14 tools are well-scoped for a generation-to-YouTube pipeline. Each stage has dedicated tools, and the four pipelines add useful high-level entry points without becoming bloated.
The surface covers the full workflow from text/image/model input through retexture, rig, animate, render, encode, and upload, with status checks throughout. The main gap is that animate_model refers to Meschy's action library without a tool to list available actions.
Maintenance
Related MCP Connectors
Generate game-ready 3D models, textures, and audio from natural language, over MCP.
Generate AI images and videos from any compatible MCP client.
Generate AI video, images and audio, and browse your history, from any MCP client.
Make, render and auto-post AI faceless videos to YouTube, TikTok and Instagram from any MCP client.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables natural language control of Blender 3D through MCP clients, allowing creation, modification, and manipulation of 3D models, animations, and scenes.302MIT
- AlicenseNot gradedqualityDmaintenanceMCP server that integrates Blender with CSM.ai 3D assets and LLM agents, enabling AI-assisted 3D modeling and animation through natural language commands.1MIT
- AlicenseAqualityDmaintenanceAn MCP server that takes a text prompt and automatically generates a 3D model turntable video and publishes it to BoTTube.159MIT

Context3D MCP Serverofficial
AlicenseBqualityDmaintenanceEnables AI-powered 3D model generation from text and images with PBR textures, supporting blockchain authentication and MCP integration.7MIT