Aseprite Claude Connector MCP

Put a sketch or reference on a faded, locked layer on top of the sprite, across every frame, and keep the active layer as it was, so drawing lands on the art.

A short list of what Claude changed this session, oldest first: each edit, how many times in a row, the frames and layers it touched, and pixels changed. Repeats on the same layer are merged. `last` limits it to the most recent edits. It covers the most recent 500 edits since the server started,…

Say which Aseprite tool, menu, or shortcut would do what Claude just did, so you pick up the technique. Covers the `last` most recent edits, newest repeats merged. Shortcuts are Aseprite's defaults.

Start recording this session: a picture of the active frame is kept after every edit, for `stop_recording to turn into a GIF timelapse. Each picture is one more read of the sprite, so edits run a little slower while it's on. Starting again throws away what's recorded. Headless: pass file`.

Stop recording and write the timelapse GIF to `out_path. It's zoomed with sharp pixels to fit max_size, and the final picture holds for a beat before it loops. Larger GIFs take longer to encode, so raise max_size` with care.

Redraw a character's eyes, frame by frame, to give it an expression:

Swing a wing, arm, tail or ear about its joint across frames. `outline is a polygon round the part, in canvas pixels [[x, y], ...]; keep it to the part itself (not the face or chest beside it). pivot` is the joint.

Breathing, hops and sways: everything above the row `feet_y moves while the feet below it stay planted. Put feet_y` at the top of the feet.

Move floating symbols ("!", "?", Zzz, hearts, sparkles) off a character's layer onto a new layer, and animate them there. `boxes are [x, y, w, h] round each symbol (or group); only pixels not joined to the body are taken, so a box can overlap a wing. They're found on from_frame` and…

Compare sprites of one character or set: the open sprites (live; `only picks them by filename or tag), or files`. Reports colours so close they should be one (the drift you get from pixelating poses separately), the colours only one sprite uses, and how tall the subject stands on frame 1 of…

Put sprites of one character or set on one shared palette: colours closer than `tolerance that stand in for each other (one sprite uses one, another sprite the other) merge into whichever is used most, across the open sprites (live; only picks them by filename or tag) or files`. Alpha is…

Set individual pixels: `pixels` is a list of

Stroke connected line segments through `points (ordered [x, y] pairs); close=True joins the last point back to the first. One undo step. Headless: pass file`.

Draw a rectangle on the active layer + frame. `color is #rrggbb or #rrggbbaa. fill` false draws only the outline. One undo step (live).

Draw a 1px line from (x1,y1) to (x2,y2). One undo step. Headless: pass `file`.

Draw a circle centered at (center_x, center_y). `fill true fills the disk. One undo step. Headless: pass file`.

Flood-fill the contiguous same-color region at (x, y). Most reliable on RGB sprites. One undo step. Headless: pass `file`.

Draw an ellipse centered at (center_x, center_y) with independent x/y radii.

Fill a rectangle with a linear gradient from `color1 to color2`.

Fill a rectangle with a uniform ordered (Bayer 4x4) dither mixing `color1 and color2. density 0..1 is the fraction of color2 — 0.5 is an even checker-style mix. One undo step. Headless: pass file`.

Add a 1px outline around the opaque pixels of a layer, in `color — readability against busy backgrounds. selective true ignores color and darkens each neighbouring pixel's own color instead, for a softer outline that follows the art (RGB sprites). diagonal` true also outlines…

See the canvas: returns a frame as an image, scaled up with sharp pixels.

See an animation: returns a tag or frame range as one image, frames left to right and top to bottom. Defaults to every frame, capped at 64. A range of up to 6 frames is a strip and longer ones are a grid, unless `columns is set. The result lists each cell's frame and duration. layer`,…

See motion: returns `frame as an image with earlier frames ghosted in red and later frames in blue, so the whole arc shows at once. Defaults to the active frame. The picture form of render_onion_composite. Headless: pass file`.

Fill in `count frames between the key pose on from_frame and the one on the next frame, then return a picture of the result. Unlike tween_frames` it handles a pose that changes shape: both poses slide toward each other and trade pixels through an ordered dither, so no new colors appear.…

Lay down a timed, tagged walk or run skeleton to draw over. It adds `frames` frames (an even number, 4-16), or uses the sprite if it's a blank single frame, with a locked faded guide layer and an empty art layer above it, which it leaves active. The near limbs are light blue and the far limbs…

Set frame durations from a preset, over a tag or a frame range (every frame by default). `ease_in starts slow and speeds up, ease_out slows to a stop, ease_in_out does both, hold keeps the last frame on screen, and bounce` hangs at the middle and snaps through both ends.…

Check whether an animation loops cleanly: compares its last frame with its first against the steps inside the loop. `verdict is smooth, jump, duplicate (the last frame repeats the first, which stutters), static, or pingpong, and seam_bbox` says where a jump is, ready to…

Insert `count in-between frames between from_frame and to_frame that slide the start frame's art toward where the end frame's art sits, so it works for moved cels and for art redrawn in a new place. It moves the art without reshaping it, and refuses if the art hasn't moved. easing`:…

Fade a layer's cels across [from_frame..to_frame]: opacity

Append a motion-smear frame blending `from_frame and to_frame`:

Pixel-exact diff of two composited frames: changed-pixel count and ratio, the bounding box of the change, and whether they're identical. Use it to verify an animation actually moves — or that an edit didn't leak into frames it shouldn't touch. Headless: pass `file`.

Write a PNG of `frame with up to prev earlier frames ghosted in red and next later frames ghosted in blue (Aseprite's onion-skin convention) at the given ghost opacity — so you can *see* the motion arc in one image. Does not modify the sprite. Headless: pass file`.

Measure the transparent 'sticker' padding around the content: content bounding box, per-side padding (left/right/top/bottom), fill ratio, and distinct opaque color count. Read-only. Headless: pass `file`.

Audit the active sprite against project conventions and return per-check pass/fail. Any rule you pass is checked: exact canvas size

Write sprite strips GameMaker cuts up by itself: one

Pack several sprites into one texture, with every frame of each, plus a JSON map in the hash layout of Aseprite's sprite-sheet export. Frames that repeat exactly share pixels. `sprites` are files on disk or, live, the file names of open sprites; unsaved sprites can't be named. The JSON goes…

Export every `.aseprite in folder (first frame) to an image, optionally integer-upscaled by scale. Non-destructive: writes <name>.<format> to out_dir (default = folder); never modifies the source. Continues past per-file errors. Headless. (file` is ignored — this operates…

Resize every `.aseprite in folder (first frame, nearest-neighbor) and write images to out_dir. Give either scale (multiplier) or explicit width/height`. Non-destructive; continues past per-file errors. Headless.

Palette-lock every `.aseprite in folder: snap each sprite (first frame, alpha preserved) to a palette and export images to out_dir. Give a preset (gameboy/pico8/cga) or an explicit palette` list of #rrggbb. Non-destructive;

Stamp an image at each [x, y] in `points` (points are stamp centers).

Create a new sprite. Live: opens a new untitled sprite in the editor and makes it the sprite Claude works on, even if the artist clicks another tab.

Grow (or shrink, with negatives) the canvas per side WITHOUT scaling content — existing pixels keep their positions relative to the old origin. One undo step. Headless: pass `file`.

Slice a sheet PNG into animation frames: cells are read row-major at the given frame size onto a new "imported" layer, adding frames as needed. The sheet's dimensions must be exact multiples of the frame size. One undo step. Headless: pass `file` (the target sprite).

Empty the cel at the given layer + frame (transparent).

Move the cel's top-left origin to (x, y).

Set the cel's opacity (0-255).

Find pixels and colors that look like accidents, and return a picture of

Recolor the sprite into team colors or seasons in one batch. `variants maps each variant's name to a color swap, like {"red": {"#3050c0": "#c03030"}, "green": {"#3050c0": "#30a040"}}. Writes one strip <name>_<variant>.png per variant into output_dir`, frames left to right, and…

Replace every pixel matching `from_color (within tolerance, a 0-255 RGB distance) with to_color across the active cel, preserving each pixel's alpha unless to_color carries its own. One undo step. Headless: pass file`.

Snap every opaque pixel of the active cel to its nearest color in the sprite's palette (alpha preserved) — enforce palette discipline after intake or shading. RGB sprite; one undo step. Headless: pass `file`.

Shift the active cel's colors in HSL: `hue_shift degrees (-360..360), saturation a multiplier (1.0 = unchanged), lightness` a delta (-1..1).

Return a color histogram of the composited sprite: distinct opaque color count, total opaque pixels, and the `top most-used colors with counts — a palette-drift check for the art-QA loop. Read-only. Headless: pass file`.

Search Aseprite's Lua scripting API reference, bundled with this server.

Search Aseprite's user manual: how features work in the editor, such as tilemaps, onion skinning, or slices. The first search downloads the manual from GitHub to your cache, then it refreshes every 30 days.

Make a frame active, so the next edits land on it. Headless forgets this between calls, so use it as a step in `edit_batch` there.

Make a layer active, so the next edits land on it. `name may be a "Group/Layer" path. Headless forgets this between calls, so use it as a step in edit_batch` there.

Undo the last edit on the active sprite (live editor).

Redo the last undone edit (live editor).

Export the active sprite to a file; format is chosen by `out_path extension (.png, .gif, ...). A multi-frame sprite saved to a single-image format is split into <name>1.ext, <name>2.ext, ...; a multi-frame sprite saved to .gif` becomes one animated GIF (all frames, honoring per-frame…

Pack all frames into a single sprite-sheet image (optionally writing a JSON atlas to `data_path). sheet_type is rows | columns | horizontal | vertical | packed. Does not modify the sprite. Headless: pass file`.

Export every image layer (recursing into groups) as its own PNG in `out_dir, named <sanitized-layer-name>.png`. Hidden layers are exported too; every layer's original visibility is restored afterwards, so the document ends exactly as it started. A multi-frame sprite splits each layer into…

Export each animation tag's frame range as its own file in

Adjust the active cel's brightness and contrast, each -100..100 (0 = unchanged). Alpha is preserved. One undo step. Headless: pass `file`.

Invert the active cel's RGB (alpha untouched). One undo step.

Convert the active cel to grayscale (Rec. 601 luma), keeping alpha.

Blur the active cel with an alpha-weighted box kernel. `radius` 1-4 (1 = 3x3). Transparent neighbors don't darken edges. One undo step.

Sharpen the active cel (unsharp mask over a 3x3 neighborhood).

Write the animation (or one `tag) as a looping .gif or animated .png at path, scaled up scale times with sharp pixels (4 turns a 384x128 banner into 1536x512). Each frame keeps its own duration. An animated PNG keeps transparency; a GIF is laid on background` (#rrggbb, black…

Turn rough sketched strokes into clean pixel-art lines: `thin` brings thick strokes down to one pixel, and the doubled corner pixels freehand lines leave are removed, as Aseprite's pixel-perfect brush would have drawn them.

Append a new empty frame.

Duplicate frame `number` (1-based).

Delete frame `number` (1-based). Cannot delete the last frame.

Set frame `number`'s duration in milliseconds.

Append `count` empty frames in one undo step.

Set every frame in [from_frame..to_frame] to `ms` milliseconds.

Reverse frame order (cels on every layer, plus durations) — the whole sprite by default, or the inclusive [from_frame..to_frame] range. One undo step.

Configure the editor's onion-skin view: on/off, ghost counts each direction, and whether ghosting stays inside the current tag. A view preference — visually meaningful in the live editor. (For a rendered onion-skin image any backend can produce, use `render_onion_composite`.)

Export the sprite into a game project in one action, ready to select in the engine. `game_dir is the project folder; it's remembered, so leave it out after the first time. Godot is detected from project.godot, Unity from Assets plus ProjectSettings`, and any other folder gets a plain…

Export a horizontal sprite sheet AND a Godot 4 `SpriteFrames .tres beside it, with one animation per tag, keeping each frame's timing, the tag's direction, and its repeat count. No tags gives one looping default animation. Export inside a Godot project and the res://` path is worked…

Report backend health plus this server's version and whether a newer release exists. Live: whether Aseprite is connected + its version.

Takes no parameters.

Get the active sprite's size, color mode, and layer/frame/tag lists.

Summarize the active sprite in one call: size, color mode, the layer tree with visibility and blend modes, frame timing, tags, slices, palette, the selection, and what's active. Frame durations and palette colors stop at 64 entries; `count` always gives the full number.

Read one composited pixel (all layers) at (x, y) as #rrggbbaa.

Attach typed key/value metadata to the sprite (Aseprite's Properties system — stored in the .aseprite file itself). Values may be strings, numbers, or booleans. Useful for provenance ("generated_by", spec IDs) and pipeline state. One undo step.

Read the sprite's typed key/value metadata (Properties).

Read a composited pixel region as a grid of #rrggbbaa strings — the AI feedback loop for 'what does the canvas look like now'. Capped at 4096 px;

Draw a 2:1 isometric box. The footprint diamond is centered at (center_x, center_y) with the given `half_width (full tile width = 2×half_width), rising height px. Top/left/right faces are auto-shaded from color` (#rrggbb, light from top-left) with stroke + highlight.

Draw a vertical isometric cylinder (tank/silo/chimney): top ellipse + shaded body + front rim, auto-shaded from `color. top_y is the top of the body. One undo step. Headless: pass file`.

Scanline-fill an arbitrary polygon given `points (a list of [x, y] pairs, in order). color` is #rrggbb or #rrggbbaa. One undo step.

Draw a recessed docking socket/port on an isometric face — a light lit lip framing a dark recessed interior. `points = the 4 corner [x, y] pairs of a face (e.g. the face_se returned by draw_iso_box). This is the consistent I/O-port style. One undo step. Headless: pass file`.

Add a new empty layer (optionally named) at the top of the stack.

Add a layer group. Move layers into it with `move_layer_to_group`;

Move a layer inside a layer group.

The full layer tree, top of stack first: name, path, kind

Delete the layer with the given name.

Rename a layer.

Show or hide a layer.

Set a layer's opacity (0-255).

Flatten all layers into a single layer.

Set a layer's blend mode. One of: normal, multiply, screen, overlay, darken, lighten, color_dodge, color_burn, hard_light, soft_light, difference, exclusion, hue, saturation, color, luminosity, addition, subtract, divide.

Duplicate a layer (with its cels) above the original.

Merge a layer into the layer directly beneath it.

Reorder a layer in the stack. `direction` is up | down | top | bottom (bottom = stack index 1).

Import an external image file (PNG, etc.) into a new layer at (x, y) — a reference/trace layer for concept-art intake. One undo step. Headless: pass `file`.

Show a scene at another time of day: `dawn, noon, sunset, or night. Each colour's lightness, warmth, and saturation shift the way that light would, and each maps to one new colour, so the colour count stays the same. glows are lanterns or windows, [[x, y, radius], ...]`,…

Make a normal map so the art reacts to 2D lights in Godot and Unity: a torch moving past shades it. Forms round off over `bevel pixels from their outline, detail (0-1) lets bright areas stand forward, and strength` steepens it all. It goes on a hidden "Normal map" layer, and…

Live editor only: current zoom, scroll, and which sprite pixel the mouse is over — lets an agent know what the artist is looking at.

Takes no parameters.

Live editor only: set the viewport zoom (1.0 = 100%) and/or scroll — e.g. zoom to the region you're about to edit so the artist can watch.

Live editor only: set mirror-painting symmetry — `mode is none, horizontal (mirror across a vertical axis), vertical, or both`; optionally place the axis lines. Affects the artist's subsequent brush strokes.

Live editor only: ask the ARTIST to click a point on the canvas (pivot, anchor, paint origin). Returns immediately; call

Poll the result of `ask_point: done false while waiting, then the clicked x/y (or cancelled` if the artist pressed Esc).

Takes no parameters.

Withdraw a pending `ask_point` request (e.g. the artist stepped away and you're moving on).

Takes no parameters.

Live editor only: pop a small dialog IN Aseprite with a message and up to 4 option buttons (e.g. approve/redo). Non-blocking — call `get_dialog_choice` to collect the artist's pick.

Poll the result of `show_choice_dialog: done` false while the dialog is open, then the chosen button text.

Takes no parameters.

Live editor only: start counting edits the ARTIST makes to the active sprite (via `Sprite.events). Poll with get_watched_changes` — e.g.

Takes no parameters.

Poll the change counter started by `watch_changes (reset=True` zeroes it after reading).

Detach the `watch_changes` listener.

Takes no parameters.

Run arbitrary Lua inside Aseprite and return its result (advanced escape hatch — equivalent to local code execution). `J(value) is available for JSON returns; wrap your own edits in app.transaction` for clean undo.

Return the active sprite's palette as #rrggbbaa hex strings.

Set palette entry `index to color` (#rrggbb or #rrggbbaa).

Append `color` to the palette and return its new index.

Replace the whole palette with `colors` (list of #rrggbb/#rrggbbaa).

Replace the palette with a built-in preset: gameboy | pico8 | cga.

Generate a dark->light shading ramp from `base_color and APPEND it to the palette in order — ready for palette_ramp_walk. count` colors;

Extract a palette (median-cut) from an external image file and, by default, set it as the active sprite's palette — the concept-art → locked-palette step.

Reorder palette swatches by `luminance (default), hue, or saturation`. Intended for RGB sprites' swatch organization — on an INDEXED sprite this changes which color each pixel shows (indices aren't remapped). One undo step.

Derive the palette FROM the sprite's actual pixels (Aseprite's color quantization) — the inverse of `quantize_to_palette`. Returns the new palette as hex. One undo step.

Replace the sprite's palette from a palette file (.gpl, .pal, .ase, .png strip — anything Aseprite reads). One undo step.

Write the sprite's palette to a file (.gpl, .pal, .png — by extension).

Apply one of Aseprite's bundled extension palettes by resource ID — e.g. DB16, DB32, ARQ4, EDG16 (availability depends on the installed palette extensions). For gameboy/pico8/cga see `apply_preset_palette`.

Cut a character sheet (poses in a `columns x rows grid) into one pixel-art sprite per pose, all at the same scale and on ONE shared palette of colors colours (or palette), so the poses stay consistent with each other. Each cell is shrunk to width x height` (the cell's aspect…

Turn a reference picture into pixel art on a new layer: the faithful way to recreate a photo or painting. The picture (or the `crop_* part of it, in its own pixels) is shrunk to width x height by averaging, so each pixel is the true colour of that area. height` defaults to the…

See how close the canvas is to a reference picture. Returns the reference shrunk to the canvas size, the canvas, and a heatmap (red = most different) side by side, plus scores out of 100: `score per pixel, shape_score` with fine detail blurred away (composition, values, and colour masses),…

Animate a character made of part layers like a cut-out puppet. `poses are key poses: {"frame": 1, "part": "Arm", "angle": -20, "x": 0, "y": 1}, with angle in degrees clockwise and x/y a move in pixels; any left out are 0. Frames between keys are filled in (easing` is…

Set the safety rails for this session, or pass nothing to read them.

Run several editing tools as one undo step, so one Ctrl-Z reverts them all.

"Fix this bit": run editing tools so they change only what's inside the current selection, as one undo step. Anything they'd do outside it, on any layer or frame, is put back. Steps are written as in `edit_batch. Select the area in Aseprite first; look with selection` shows what's…

Bring a still scene to life as a seamless loop. `layer (the active layer by default) is animated from from_frame` over

Separate a picture into parts on their own layers, like armour and meadow, so each can be edited or animated alone. `seeds` are points on each part:

Grow the canvas by `left/right/top/bottom pixels and fill the new space on layer (the active one) by continuing its own texture, like turning a portrait scene into a wide banner. Patches of patch pixels are copied from the sample_*` area (all of the layer by default) and…

Make pixelated or noisy art read as drawn: every patch of one colour smaller than `min_region pixels merges into the colour around it, if that colour is close (tolerance, 0-1; standout specks like flowers stay), and firm_edges` darkens the shadow side of strong edges with the art's own…

Set a rectangular selection. Most meaningful on the live editor.

Select the whole canvas.

Clear the current selection.

Select an ellipse inscribed in the given rectangle. `mode is replace (default), add, or subtract` against the current selection.

Select every pixel matching `color` (composited, within

Invert the current selection against the canvas bounds.

Report whether a selection exists and its bounding rectangle.

Erase pixels to transparent. Pass an explicit rect (works everywhere, including headless), or pass nothing to erase the current selection — including non-rectangular ones (live editor). One undo step.

Open a sprite file and make it the active document; returns its filename, size, and frame/layer counts. Live: opens a new tab in the editor and makes it the sprite Claude works on. Headless: each call is a fresh process, so this is a "can Aseprite read this file" probe returning the file's info —…

Save the active sprite to disk: to `path if given (save-as; the document's filename follows it), else to its own filename — errors if the sprite is untitled and no path is given. Live: persists the edits sitting in the open editor. Headless: mutating tools already save to file` on their…

Close the active sprite. Errors if it has unsaved changes unless `force=true` — save_sprite first, or force to discard them. Aimed at the live editor (frees the tab); headless has no persistent session, so there is nothing to close there.

Live editor only: make one of the open documents active, found by exact filename or basename match (e.g. "turret.aseprite"). Returns which sprite matched and how. Subsequent tools operate on it, even if the artist clicks another tab. Unsaved sprites share a name: pick those with `pin_sprite`.

Live editor only: choose the sprite Claude's edits go to. Every tool then works on it even while the artist looks at another tab. Pick it by `filename (full path or basename), by a tag` it has (the way to tell unsaved sprites apart), or give neither to pin the sprite the artist has open now…

Live editor only: save open work into `folder as .aseprite` files, so nothing is lost when tabs are closed. Unsaved sprites are saved there and become those files (named after their first tag); sprites that already have a file and unsaved changes are COPIED there, leaving their own file…

Live editor only: list every open document — filename (or

Takes no parameters.

Palette-constrained shading: brighten toward the light and darken away from it, snapping every pixel to the nearest palette color. `intensity ~0..1. RGB sprite only; one undo step. Headless: pass file`.

Shade by WALKING the arranged palette ±N indices toward lighter/darker (per light direction), instead of snapping to the luminance-nearest color — so hand-ordered shading ramps are respected. `steps` = max indices to walk at the fully-lit/shadowed edges. RGB sprite with an ordered ramp palette;

Create a named slice (atlas region) at the given rectangle. Slices become Unity sprites via export_unity_slices. One undo step. Headless: pass `file`.

Set a slice's pivot point, in pixels relative to the slice's top-left. This pivot is exported into the Unity `.meta by export_unity_slices. One undo step. Headless: pass file`.

Set a slice's 9-patch stretchable center rectangle (relative to the slice).

List every slice with its bounds, pivot, and 9-patch center. Read-only.

Delete the slice with the given name. One undo step. Headless: pass `file`.

Create an animation tag named `name spanning frames from_frame..to_frame` (1-based).

Delete the animation tag named `name`.

List animation tags with their frame ranges.

Rename the animation tag `old_name to new_name`. One undo step.

Set the timeline label color of the tag `name (#rrggbb or #rrggbbaa). One undo step. Headless: pass file`.

Move the tag `name to span frames from_frame..to_frame (1-based, inclusive; validated against the sprite's frame count). One undo step. Headless: pass file`.

Set the playback direction of the tag `name: forward | reverse | pingpong | pingpong_reverse. One undo step. Headless: pass file`.

Create a tilemap layer with its own tileset on a tile_width x tile_height grid. The new tileset starts with only tile 0, the reserved empty tile — use add_tile to append editable tiles. One undo step. Headless: pass `file`.

Append an empty tile to a tilemap layer's tileset; returns the new tile's index and the tileset size. The first added tile is index 1 (tile 0 is the reserved empty tile). One undo step. Headless: pass `file`.

Set pixels on one tile of a tilemap layer's tileset. `pixels is a list of {x, y, color} objects (color #rrggbb or #rrggbbaa; x/y relative to the tile's top-left). Pixels outside the tile are skipped and counted. Every placed instance of the tile updates. One undo step. Headless: pass file`.

Place tile references on a tilemap layer's cel. `tiles` is a list of {column, row, index} objects (0-based grid cells; index 0 erases to the empty tile). The cel is created or grown as needed, anchored at the sprite origin.

Read a tilemap layer: tile size, tileset length, and the cel's grid size, pixel position, and tile-index grid (`tiles as rows of columns, flip flags stripped; capped at 64x64 with truncated set). Read-only. Headless: pass file`.