spine-mcp
Provides tools for creating, editing, validating, and animating Esoteric Software Spine 2D skeletal animation skeletons, including bones, slots, attachments, skins, events, constraints, keyframes, and use of the official Spine CLI for import/export.
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., "@spine-mcp Create hero.json with a root bone and a two-bone leg, then validate it"
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.
# spine-mcp
A Model Context Protocol server for Esoteric Software Spine 2D skeletal animation. It lets an AI assistant (Claude, Cursor, …) create, edit, validate and animate Spine skeletons without the editor running, and drives the official Spine CLI for import and export when the editor is installed.
Türkçe: README.tr.md
26 tools: bones, slots, attachments (region, mesh, point, bounding box, path), skins, events, IK / transform / path / physics constraints, keyframes on every Spine 4.x timeline, and rename/delete with reference cleanup.
Writes exactly what the runtimes read. Output follows
SkeletonJsonfrom the official runtimes (valuekeys,inherit,drawOrder,light/dark, absolute per-channel bezier curves, and the 4.3constraintslist or the 4.2 per-type lists depending on the file's version).Checked against the official runtime. The test suite loads generated files with
@esotericsoftware/spine-core4.3 and checks real poses (IK, constraint mixes, path positions, easing curves).Easy curves: pass
"ease-in-out"or a CSS-style normalized[cx1, cy1, cx2, cy2]; it is converted to Spine's absolute bezier values and keeps its shape when keys are added later.Safe edits: every write keeps a
<file>.bakbackup and returns validation problems.One dependency: the official
mcpPython SDK (1.x and 2.x supported).
Unofficial project. Spine is a trademark of Esoteric Software LLC. This project is not affiliated with or endorsed by Esoteric Software. You need your own Spine license to use the Spine editor and CLI features.
Contents
Related MCP server: Spine Motion MCP
How it works
The Spine editor's own .spine project files are a binary, undocumented format. spine-mcp edits
the documented Spine skeleton JSON instead, and uses the Spine CLI to move between the two:
spine_create_project("hero.json") → add bones, slots, attachments, constraints, animations
spine_validate("hero.json")
spine_import_data(project="hero.spine", data_file="hero.json") # a project the editor can open
spine_export(project="hero.spine", output="export/", pack=true) # runtime JSON/binary + atlasHave only a .spine file? Export it to JSON first (spine_export(format="json")). Editing tools
detect binary files and say so.
Installation
Requires Python 3.10+. The Spine editor is optional (needed only for spine_export,
spine_import_data and spine_cli_info).
Option A: run straight from GitHub with uvx (no clone)
With uv installed, MCP clients can start the server directly:
command: uvx
args: ["--from", "git+https://github.com/UmutFarukDilli/spine-mcp", "spine-mcp"]Option B: clone and install
git clone https://github.com/UmutFarukDilli/spine-mcp.git
cd spine-mcp
python -m venv .venv
# Windows
.venv\Scripts\python -m pip install -e .
# macOS / Linux
.venv/bin/python -m pip install -e .The server command is then the venv's Python with -m spine_mcp:
OS |
|
Windows |
|
macOS / Linux |
|
Installing the package (pip install -e .) matters: MCP clients start the server from another working
directory, so python -m spine_mcp must work from anywhere. Check with:
/path/to/spine-mcp/.venv/bin/python -c "import spine_mcp; print(spine_mcp.__version__)"Spine CLI (optional)
The server finds the editor's CLI automatically (Spine.com / SpineTrial.com on Windows,
Spine.app on macOS, Spine.sh on Linux, or anything on PATH). Point it at a specific install with
the SPINE_CLI_PATH environment variable. Run the spine_doctor tool to see what it found.
Connecting to Claude and other clients
All clients use the same three values; examples below use Option B on Windows. Adjust the paths
(or use the uvx command from Option A).
{
"mcpServers": {
"spine": {
"command": "C:\\path\\to\\spine-mcp\\.venv\\Scripts\\python.exe",
"args": ["-m", "spine_mcp"],
"env": { "SPINE_CLI_PATH": "C:\\Program Files\\Spine\\Spine.com" }
}
}
}env is optional.
Claude Code (CLI, or the Code tab of the Claude desktop app)
claude mcp add spine --scope user -- /path/to/spine-mcp/.venv/bin/python -m spine_mcp
# with a Spine CLI path:
claude mcp add spine --scope user -e SPINE_CLI_PATH="/Applications/Spine.app/Contents/MacOS/Spine" -- /path/to/spine-mcp/.venv/bin/python -m spine_mcpWithout the CLI, add the "spine" entry to mcpServers in ~/.claude.json (user scope, with
"type": "stdio"), or to a project's .mcp.json to share it with that project.
Claude Desktop (chat)
Settings → Developer → Edit Config opens claude_desktop_config.json. Add the mcpServers block
above at the top level, leaving the other settings as they are. Usual locations:
OS | File |
Windows |
|
macOS |
|
Cursor and others
Cursor reads the same block from .cursor/mcp.json. Any other MCP client: use the command, args and
env above (stdio transport).
After adding it
Config is read at startup: quit the app completely and reopen it (start a new session in Claude Code). Then ask, for example, "run spine_doctor".
Problem | Fix |
Tools do not show up | Restart the app fully; check the JSON for missing commas or unescaped |
| Run |
Test the server by hand | Run the command yourself; it should wait silently for input (Ctrl+C to quit) |
Tools
Discovery and validation
Tool | Description |
| Python/MCP versions, detected Spine CLIs and their versions, hints |
| Binary |
| Version, bone tree, slots, skins, constraints, animations, events |
| Errors and warnings: duplicate names, missing parents, broken attachments and meshes, timelines with unknown targets, unsorted keys, out-of-range curves, fields the runtime ignores, 4.2/4.3 constraint layout |
Creating
Tool | Description |
| New Spine 4.x skeleton JSON with a |
| Bone (parent, length, x/y, rotation, scale, shear, |
| Slot (bone, setup attachment, color, dark color, blend, draw-order index) |
|
|
| Skin (outfit/variant), optionally copied from another skin |
| Event with int/float/string/audio/volume/balance |
Constraints
Written in the file's format: the 4.3 typed constraints list (order = list position) or the 4.2
ik / transform / path / physics lists (with order).
Tool | Description |
| 1- or 2-bone IK (mix, bend direction, softness, stretch, compress) |
| Bones copy a source bone's rotate/x/y/scaleX/scaleY/shearY with per-property mix and offset, |
| Places bones along a |
| Spring physics for hair, tails and cloth (x/y/rotate/scaleX/shearX response, inertia, strength, damping, mass, wind, gravity) |
Animating
Tool | Description |
| Empty animation |
| Keys for |
| Remove keys at given times, or a whole timeline |
| Copy an animation (e.g. |
| Remove an animation |
Curve presets: linear, stepped, ease, ease-in, ease-out, ease-in-out, smooth, or a
normalized [cx1, cy1, cx2, cy2]. In transform and path.mix keys, mixes you leave out keep the
constraint's setup value (runtimes would otherwise treat them as 1 and switch on unused properties).
Fixing
Tool | Description |
| Change the setup pose; |
| Bone, attachment, colors, blend, draw-order position, |
| Delete a bone ( |
| Convert files written by spine-mcp 0.1 to correct 4.x fields (editing tools do this automatically) |
Spine CLI (editor required)
Tool | Description |
| JSON or binary export, optional atlas packing, animation clean-up, |
| Import JSON/binary skeleton data into a |
|
|
Example
A conversation like "make a character with a waving arm" turns into calls such as:
spine_create_project(project="hero.json", name="hero", width=512, height=512)
spine_add_bone(project="hero.json", name="hip", parent="root", y=120)
spine_add_bone(project="hero.json", name="torso", parent="hip", length=80, rotation=90)
spine_add_slot(project="hero.json", name="torso", bone="torso")
spine_add_attachment(project="hero.json", slot="torso", name="torso", kind="region", width=64, height=120)
spine_set_keyframes(project="hero.json", animation="idle", timeline="rotate", target="torso",
curve="ease-in-out",
keys=[{"time": 0, "value": 0}, {"time": 1, "value": 8}, {"time": 2, "value": 0}])
spine_validate(project="hero.json")examples/demo.json is a complete character (13 bones, 10 slots, idle / walk / wave animations,
events, placeholder images in examples/images/), built by examples/make_demo.py (needs Pillow).
Development and tests
pip install -e ".[test]"
pytesttests/test_project.py: the document model (curves, constraints, upgrade, rename/delete)tests/test_validation.py: validation rulestests/test_cli.py: CLI detection and command buildingtests/test_stdio.py: end-to-end MCP calls over real stdio JSON-RPCtests/test_runtime.py: loads and poses generated files with the official Spine runtime (needs Node.js 18+ andnpm ciintools/; skipped otherwise)
cd tools && npm ci && cd ..
node tools/verify_runtime.mjs examples/demo.json # load + play every animation
node tools/sample_pose.mjs examples/demo.json walk 0,0.5 leg-front,hip # bone world valuesCI runs the suite on Windows, macOS and Linux with Python 3.10 and 3.13, plus mcp<2.
See CONTRIBUTING.md.
@esotericsoftware/spine-core is only a development dependency for these checks; it is not bundled
with or required by the server. It is covered by the
Spine Runtimes License.
Limitations
No editor GUI automation. The Spine CLI only exports, imports, packs and reports info; spine-mcp adds JSON editing on top of it.
Binary
.spineprojects cannot be edited directly (see How it works). Spine 3.x JSON is refused for editing;spine_validatewarns about it.4.3
sliderconstraints are read and validated, but no tool creates them yet.The 4.2 constraint layout was checked by hand with
spine-core4.2; automated runtime tests use 4.3.CLI features need a licensed Spine editor. The Spine Trial does not export, so
spine_exporttimes out with it; the generated command can be checked withdry_run=true.Mesh attachments are generated as regular grids; pass
uvs/vertices/triangles/hullfor custom meshes, or refine them in the editor.CLI exports must match your runtime version (a Spine rule).
License
Available Tools
26 toolsspine_add_animationB
Create an empty animation. Add keyframes afterwards with spine_set_keyframes.
Inputs: name (required), project (required). Returns: result
spine_add_attachmentA
Attach something to a slot inside a skin (registration + optional setup assignment).
Kinds:
region - textured rectangle centered on x/y; needs width/height.
image_pathis the region name inside the images folder/atlas, without extension (defaults to the attachment name; a .png suffix is stripped).mesh - textured mesh; a regular grid centered on x/y is generated from width/height/cols/rows unless explicit uvs/vertices/triangles are given (then list the outline vertices first and pass
hull= their count).point - single point with rotation (projectile/particle spawn).
boundingbox - polygon for hit detection; needs
vertices(x,y pairs).path - curve for spine_add_path_constraint;
verticesare the anchor points (x,y pairs, in the slot bone's space). Smooth handles and the curve lengths are generated.closedmakes a loop;constant_speed(default) keeps bones evenly spaced along it.
Args: assign: Also set this attachment as the slot's setup-pose attachment. skin: Skin to put the attachment in (created if missing).
Inputs: name (required), slot (required), project (required), x, +19 more. Returns: result
spine_add_boneC
Add a setup-pose bone. The bone is inserted after its parent's subtree so that "parents always come first" stays valid. Returns the resulting bone tree.
Args:
inherit: normal, onlyTranslation, noRotationOrReflection, noScale or noScaleOrReflection.
transform: Deprecated alias of inherit (the pre-4.2 field name).
skin: Only active while a skin that contains it is active.
color: Optional bone color as RRGGBB or RRGGBBAA.
Inputs: name (required), project (required), x, y, +11 more. Returns: result
spine_add_eventC
Define a named event (setup-pose values) that animations can trigger.
Args: int_value: Integer payload. float_value: Float payload. string: String payload. audio: Audio path played by the event. volume: Audio volume (default 1). balance: Stereo balance, -1..1 (default 0).
Inputs: name (required), project (required), audio, string, +4 more. Returns: result
spine_add_ik_constraintA
Add an IK constraint: 1 bone points at the target, 2 bones (parent, direct child) bend like a limb so the child's tip reaches the target. Animate it with timeline "ik".
Args:
bones: [bone] or [upper, lower], e.g. ["thigh", "shin"].
target: Bone to reach (must not be one of bones or their children), e.g. "foot-target".
mix: 0..1 influence.
bend_positive: Bend direction of a 2-bone chain.
softness: Distance before full extension where the chain starts to slow down.
compress / stretch / uniform: Scale the bone(s) to reach the target.
order: Constraint order (default: after existing constraints).
Inputs: name (required), bones (required), target (required), project (required), +7 more. Returns: result
spine_add_path_constraintA
Add a path constraint: bones are placed along the path attachment shown in slot
(add one first with spine_add_attachment kind="path"). Animate "path.position" to move
them along it.
Args: position_mode: percent (position 0..1 of the path length) or fixed (in pixels). spacing_mode: length, fixed, percent or proportional (distance between the bones). rotate_mode: tangent, chain or chainScale. rotation: Rotation offset in degrees. position: Setup position along the path. spacing: Setup spacing between bones. mix_rotate / mix_x / mix_y: 0..1 influence (mix_y defaults to mix_x).
Inputs: name (required), slot (required), bones (required), project (required), +10 more. Returns: result
spine_add_physics_constraintA
Add a physics constraint (Spine 4.2+): the bone reacts like a spring when the skeleton moves - hair, tails, ears, cloth. At least one of x, y, rotate, scale_x, shear_x must be > 0. Animate it with "physics.wind", "physics.gravity", "physics.reset", ...
Args: x / y / rotate / scale_x / shear_x: 0..1 how much the bone reacts in each channel. inertia: 0..1, how much movement is kept from the parent (default 0.5). strength: Spring stiffness (default 100). damping: 0..1, how quickly motion settles (default 0.85). mass: > 0 (default 1). wind / gravity: Constant forces (default 0). mix: 0..1 overall influence. limit: Maximum speed (default 5000). fps: Simulation rate (default 60).
Inputs: bone (required), name (required), project (required), x, +14 more. Returns: result
spine_add_skinB
Create a skin (e.g. an outfit). Use copy_from to start from another skin's attachments,
then add or replace attachments with spine_add_attachment(skin=name).
Inputs: name (required), project (required), copy_from. Returns: result
spine_add_slotA
Add a draw-order slot attached to an existing bone.
Slots are drawn in list order (later slots on top). Use index to insert at a
specific draw position instead of appending.
Args: attachment: Name of the setup-pose attachment (must exist in a skin). color: RRGGBB or RRGGBBAA setup color. dark: 6-digit dark color for two-color tinting. blend: normal, additive, multiply or screen.
Inputs: bone (required), name (required), project (required), dark, +4 more. Returns: result
spine_add_transform_constraintA
Add a transform constraint: bones copy the source bone's rotation, position, scale
and/or shear (e.g. a cape following the torso, wheels sharing rotation). Animate it with
timeline "transform". Written in the file's format (4.3 "constraints" list or 4.2 "transform").
Args:
properties: What to copy, any of rotate, x, y, scaleX, scaleY, shearY (default all).
mix: 0..1 influence per property, e.g. {"rotate": 1, "x": 0.5} (default 1).
offsets: Constant offsets per property, e.g. {"rotate": 90, "x": 10}.
local: Use local instead of world transforms.
additive: Add to the bones' own transform instead of replacing it (4.2: "relative").
clamp: (4.3) Clamp converted values to the mapping's max.
mapping: (4.3) Raw property map for cross-property links, e.g.
{"rotate": {"to": {"x": {"scale": 2}}}} turns the source's rotation into x movement.
Overrides properties.
order: Update order among constraints (default: last).
Inputs: name (required), bones (required), source (required), project (required), +8 more. Returns: result
spine_cli_infoB
Ask the Spine CLI for project information (-i project). Shows the editor version, animation counts and warnings for files the offline parser may not understand.
Inputs: project (required), timeout. Returns: result
spine_create_projectA
Create a new Spine 4.x skeleton JSON file containing a single "root" bone.
Args: project: Target path ending in .json (the editor's .spine format is binary; convert the JSON into a real project with spine_import_data). name: Skeleton name (defaults to the file name). width: Skeleton bounds width reported in the skeleton section. height: Skeleton bounds height reported in the skeleton section. spine_version: Version string written to skeleton.spine (default 4.3.00 or $SPINE_VERSION). images: Image folder stored in skeleton.images. audio: Audio folder stored in skeleton.audio. overwrite: Replace an existing file.
Inputs: project (required), name, audio, width, +4 more. Returns: result
spine_deleteB
Delete a bone, slot, attachment, event, constraint, animation or skin and clean up everything that refers to it (timelines, draw order keys, constraints, skin entries).
Args: kind: bone, slot, attachment, event, constraint, animation or skin. slot: Required for kind="attachment". skin: Skin of the attachment (kind="attachment"). cascade: For bones: also delete child bones and their slots (otherwise refused if any exist).
Inputs: kind (required), name (required), project (required), skin, +2 more. Returns: result
spine_delete_animationB
Remove an animation (e.g. before regenerating it). Other animations are untouched.
Inputs: name (required), project (required). Returns: result
spine_delete_keyframesA
Remove keys from one timeline: the keys at times (seconds), or the whole
timeline when times is omitted. Curves of the remaining keys keep their shape.
Args: timeline: Same names as spine_set_keyframes (rotate, translate, attachment, event, drawOrder, ik...). target: Bone, slot or IK constraint name (empty for event/drawOrder).
Inputs: project (required), timeline (required), animation (required), times, +1 more. Returns: result
spine_doctorA
Check the environment: Python/MCP SDK versions, detected Spine CLI paths and versions.
Call this first when export or import fails, or to discover whether the Spine editor is installed and usable from the command line.
Inputs: no named parameters. Returns: result
spine_duplicate_animationB
Copy an animation under a new name (e.g. "walk" -> "walk-fast" before retiming it).
Inputs: name (required), source (required), project (required). Returns: result
spine_exportA
Export a .spine project through the Spine CLI (Spine -i project -o output -e json).
The editor must be installed; the executable is auto-detected or taken from
SPINE_CLI_PATH. The first run of the Trial launcher can download the editor and
therefore be slow - raise timeout if needed.
Args: output: Output folder (files are named after the skeleton). format: "json" or "binary". pack: Also pack a texture atlas (json+pack / binary+pack). clean: Animation clean-up before export (-m); does not modify the project. settings: Path to a saved export-settings JSON; overrides format/pack. timeout: Seconds to wait for the CLI. dry_run: Only return the command that would be executed.
Inputs: output (required), project (required), pack, clean, +4 more. Returns: result
spine_import_dataC
Import a Spine JSON/binary file (or another project) into a .spine project via the CLI (Spine -i data -o project -r [name]). The project is created if missing.
Inputs: project (required), data_file (required), scale, timeout, +1 more. Returns: result
spine_inspectA
Read a .spine/.json file and return its structure: version, bone tree, slots, skins, attachment counts by type, animations with durations and events.
Args: project: Path to a .spine project or exported Spine JSON. detail: "summary" (default) or "full" to include every animation track.
Inputs: project (required), detail. Returns: result
spine_list_projectsA
Find Spine files under a directory: binary .spine editor projects (type "project") and Spine skeleton JSON (type "json", with version and counts). Other JSON is skipped.
Args: root: Directory to scan (absolute or relative to the server working directory). include_json: Also look at .json files (default true). limit: Maximum number of results (1-2000).
Inputs: root, limit, include_json. Returns: result
spine_set_keyframesA
Add or replace keyframes of one timeline (the animation is created if missing).
Timelines and their key fields (written in the Spine 4.x JSON format):
rotate (bone) keys: {"time": 0, "value": 15} ("angle" is accepted too)
translate (bone) keys: {"time": 0, "x": 10, "y": -4}
scale (bone) keys: {"time": 0, "x": 1, "y": 1}
shear (bone) keys: {"time": 0, "x": 0, "y": 0}
translatex/translatey/scalex/scaley/shearx/sheary (bone) keys: {"time": 0, "value": 3}
inherit (bone) keys: {"time": 0, "inherit": "noScale"}
attachment(slot) keys: {"time": 0, "name": "eyes-closed"} (null clears)
rgba / rgb (slot) keys: {"time": 0, "color": "FFFFFFFF"} (RRGGBB for rgb)
rgba2 / rgb2 (slot) keys: {"time": 0, "light": "FFFFFFFF", "dark": "000000"}
alpha (slot) keys: {"time": 0, "value": 0.5}
event keys: {"time": 0.2, "name": "footstep", "int": 1}
drawOrder keys: {"time": 0, "offsets": [{"slot": "arm", "offset": 1}]}
ik (constraint) keys: {"time": 0, "mix": 1, "softness": 0, "bendPositive": false}
transform (constraint) keys: {"time": 0, "mixRotate": 1, "mixX": 0.5, ...} (mixRotate/mixX/mixY/mixScaleX/mixScaleY/mixShearY; omitted mixes keep the setup value)
path.position / path.spacing (constraint) keys: {"time": 0, "value": 0.25}
path.mix (constraint) keys: {"time": 0, "mixRotate": 1, "mixX": 1, "mixY": 1}
physics.inertia/strength/damping/mass/wind/gravity/mix keys: {"time": 0, "value": 30}
physics.reset keys: {"time": 0.5} (physics target "" = every physics constraint)
Curves: every key accepts "curve": "linear" (default), "stepped", a preset
("ease", "ease-in", "ease-out", "ease-in-out", "smooth") or [cx1, cy1, cx2, cy2]
normalized to the interval up to the next key (0..1, like CSS cubic-bezier).
They are converted to Spine's absolute bezier values automatically and keep their
shape when keys are added later. The curve argument is the default for keys
that do not specify one.
Args: target: Bone name for bone timelines, slot name for slot timelines, constraint name for ik/transform/path/physics. Ignored for event/drawOrder. mode: upsert (default: merge, new keys win at equal times), append (merge, error on equal times) or replace (the whole timeline).
Inputs: keys (required), project (required), timeline (required), animation (required), +3 more. Returns: result
spine_update_boneA
Change an existing bone's setup pose. Only the arguments you pass are changed.
new_name renames the bone everywhere (children, slots, constraints, skins, animations).
parent re-parents it (with its whole subtree; cycles are refused). Pass color="" to clear it.
Inputs: name (required), project (required), x, y, +11 more. Returns: result
spine_update_slotA
Change an existing slot. Only the arguments you pass are changed.
Args: new_name: Rename the slot everywhere (skins, animations, draw order keys, path constraints). bone: Move the slot to another bone. attachment: Setup-pose attachment; "" clears it (the slot starts empty). color: RRGGBB(AA) setup color; "" resets to white. dark: RRGGBB dark color for two-color tinting; "" removes it. blend: normal, additive, multiply or screen. index: New draw-order position (0 = drawn first / at the back).
Inputs: name (required), project (required), bone, dark, +5 more. Returns: result
spine_upgradeA
Fix a document written by spine-mcp 0.1: rotate "angle" -> "value", alpha -> "value", "draworder" -> "drawOrder", bone "transform" -> "inherit" and normalized curves -> absolute Spine 4.x curves. Every editing tool does this automatically; use this to fix a file as is.
Inputs: project (required). Returns: result
spine_validateA
Validate a Spine JSON project offline: duplicate names, missing parents, bones listed after their parent, unknown slot bones, malformed attachments, timelines pointing at missing bones/slots/events, unsorted keyframes and curves.
Returns {"ok": bool, "errors": [...], "warnings": [...], "stats": {...}}.
Inputs: project (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 26 tools
Each tool targets a distinct resource+action (add_bone vs update_bone vs add_slot vs set_keyframes), and the descriptions do a good job of separating near-neighbours like spine_inspect (offline parser) and spine_cli_info (editor CLI). There is some genuine redundancy: spine_delete_animation is a strict subset of spine_delete(kind="animation"), and spine_delete_keyframes overlaps with spine_set_keyframes(mode="replace"), but these are convenience shortcuts rather than true ambiguity.
All names share a spine_ prefix and snake_case, with a clear verb_noun convention (add_bone, update_slot, set_keyframes, delete_animation, create_project, list_projects). A handful of tools drop the verb (spine_inspect, spine_doctor, spine_upgrade, spine_cli_info), which is a minor deviation but still readable and consistent in style.
26 tools sits at the heavy end of the rubric for a single-purpose server. The domain is genuinely broad (bones, slots, attachments, keyframes, four constraint types, skins, export/import), but the four spine_add_*_constraint tools plus spine_add_attachment's kind-switch suggest the surface could be consolidated.
Lifecycle coverage is strong: create/inspect/validate/export/import plus add/update/delete for bones and slots, add/set/delete for keyframes and animations, and delete for every entity kind. The main gaps are the absence of update tools for constraints, events, and attachments (and no animation rename), which force a delete-and-re-add workaround.
Maintenance
Related MCP Connectors
Render Spine 3.8 skeleton animations to PNG frames or GIF. Pay per call with points.
Create AI animations and export transparent sprite sheets, alpha video, frames, and game assets.
Control Unreal Engine to browse assets, import content, and manage levels and sequences. Automate…
Turn prompts into production-ready game assets: animated characters, textures, terrain, VFX, HUD.
Related MCP Servers
- AlicenseAqualityDmaintenanceAutomates Spine asset pipeline tasks such as export, texture packing, resource validation, and file summarization through the Spine CLI.6MIT
- AlicenseNot gradedqualityDmaintenanceEnables authoring, preview, and export of Spine 2D skeletal animations via natural language from Claude Code or any MCP client, with a web dashboard and tools for keyframing, templates, and GIF preview.8MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI clients to directly control Spine 3.8.75 animation workflows through 55 MCP tools, including reading projects, editing keyframes, manipulating skeletons, constraints, meshes, atlases, and rendering previews.27 npm28MIT
- FlicenseAqualityBmaintenanceEnables converting layered PSD or PhotoshopToSpine exports into validated Spine 2D rigs, animations, atlases, previews, runtime JSON, and optionally editable .spine projects. It provides MCP tools and an OpenAI/Codex workflow for rigging, animation generation, validation, preview auditing, and batch processing.14-