Aseprite Live MCP server

Read from the package source without running it. The installed server may list more.

• add_frame

  Append a new empty frame.

• add_frames

  Append ``count`` empty frames in one undo step.

• add_group

  Add a layer group. Move layers into it with ``move_layer_to_group``; reference nested layers anywhere by name or as ``Group/Layer``.

• add_layer

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

• add_outline

  Add a 1px outline in ``color`` around the opaque pixels of the active cel — readability against busy backgrounds. ``diagonal`` true also outlines diagonally (8-connected). One undo step. Headless: pass ``file``.

• add_palette_color

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

• adjust_brightness_contrast

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

• adjust_hsl

  Shift the active cel's colors in HSL: ``hue_shift`` degrees (-360..360), ``saturation`` a multiplier (1.0 = unchanged), ``lightness`` a delta (-1..1). Useful for tint variants. One undo step. Headless: pass ``file``.

• apply_bundled_palette

  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``. One undo step.

• apply_dither

  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``.

• apply_preset_palette

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

• ask_point

  Live editor only: ask the ARTIST to click a point on the canvas (pivot, anchor, paint origin). Returns immediately; call ``get_asked_point`` to collect the click. Human-in-the-loop, in-editor.

• batch_apply_palette

  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; continues past per-file errors. Headless.

• batch_export

  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 on a folder.)

• batch_resize

  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.

• box_blur

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

• cancel_ask_pointwrite action

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

• clear_cel

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

• create_spritewrite action

  Create a new sprite. Live: opens a new untitled sprite in the editor. Headless: writes a new .aseprite to ``file`` (required). ``color_mode`` is one of rgb | gray | indexed.

• delete_framewrite action

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

• delete_layerwrite action

  Delete the layer with the given name.

• desaturate

  Convert the active cel to grayscale (Rec. 601 luma), keeping alpha. One undo step. Headless: pass ``file``.

• draw_circle

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

• draw_ellipse

  Draw an ellipse centered at (center_x, center_y) with independent x/y radii. ``fill`` true fills it. One undo step. Headless: pass ``file``.

• draw_gradient

  Fill a rectangle with a linear gradient from ``color1`` to ``color2``. ``direction`` is horizontal | vertical | diagonal. ``dither`` true uses an ordered Bayer dither between the two colors instead of blending RGB — the palette-friendly way. One undo step. Headless: pass ``file``.

• draw_iso_box

  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. Returns the top/SE/SW face corner polygons so you can attach recessed ports or details. One undo step. Headless: pass ``fi

• draw_iso_cylinder

  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``.

• draw_line

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

• draw_pixels

  Set individual pixels: ``pixels`` is a list of ``{"x": int, "y": int, "color": "#rrggbb[aa]"}``. The precision tool for detail work — one undo step for the whole batch. Capped at 4096 pixels per call. Headless: pass ``file``.

• draw_polyline

  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_rectangle

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

• duplicate_frame

  Duplicate frame ``number`` (1-based).

• duplicate_layer

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

• expand_canvas

  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``.

• export_layers

  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 ``<name>1.png``, ``<name>2.png``, ...; the returned ``files`` lists what was actually written. Headless:

• export_sprite

  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 durations). The returned ``files`` lists what was actually written. Does not modify the sprite. Headl

• export_spritesheet

  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_tags

  Export each animation tag's frame range as its own file in ``out_dir``: an animated ``<tag-name>.gif`` (format="gif", default) or a horizontal ``<tag-name>.png`` strip (format="png"). Errors if the sprite has no tags. Returns each tag's file, frame range, and frame count. Does not modify the sprite. Headless: pass ``file``.

• extract_palette_from_image

  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. Returns the colors as hex, sorted dark→light. Headless: pass ``file``.

• fill_area

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

• fill_polygon

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

• flatten_sprite

  Flatten all layers into a single layer.

• frame_diff

  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``.

• generate_color_ramp

  Generate a dark->light shading ramp from ``base_color`` and APPEND it to the palette in order — ready for ``palette_ramp_walk``. ``count`` colors; ``hue_shift`` pushes shadows toward blue and highlights toward yellow. Returns the ramp as hex. One undo step. Headless: pass ``file``.

• get_asked_point

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

• get_color_stats

  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``.

• get_dialog_choice

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

• get_editor_state

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

• get_palette

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

• get_pixel

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

• get_pixels

  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; use a smaller region or export for larger areas.

• get_sprite_info

  Get the active sprite's size, color mode, and layer/frame/tag lists. Headless: pass ``file`` (the .aseprite to inspect).

• get_sprite_metadata

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

• get_watched_changes

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

• import_image_as_layer

  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``.

• import_spritesheet

  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).

• invert_colors

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

• iso_recessed_panel

  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``.

• list_layers

  The full layer tree, top of stack first: name, path, kind (image/group/tilemap), visibility, and opacity — including layers nested in groups (which ``get_sprite_info`` lists only at the top level).

• load_palette

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

• measure_padding

  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``.

• merge_layer_down

  Merge a layer into the layer directly beneath it.

• move_layer

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

• move_layer_to_group

  Move a layer inside a layer group.

• paint_with_stamp

  Stamp an image at each [x, y] in ``points`` (points are stamp centers). The stamp comes from ``source_path`` (a PNG) or ``source_rect`` ([x, y, width, height] cut from the composited sprite). One undo step for the whole scatter. Headless: pass ``file``.

• palette_from_sprite

  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.

• qa_sweep

  Audit the active sprite against project conventions and return per-check pass/fail. Any rule you pass is checked: exact canvas size (``expected_width``/``expected_height``), ``grid_multiple`` (canvas dims divisible by N), ``max_colors`` (distinct opaque colors ≤ N), and ``require_symmetric_padding`` (equal left/right + top/bottom margins). Read-only. Headless: pass ``file``.

• quantize_to_palette

  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``.

• redo

  Redo the last undone edit (live editor).

• rename_layer

  Rename a layer.

• render_onion_compositewrite action

  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``.

• replace_color

  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``.

• reverse_frames

  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.

• run_luawrite action

  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. The prelude also provides ``editCel(fn)`` and ``findLayer(s, name)``. Set ``save=true`` (headless) to persist changes to ``file``. Your code must ``return`` a value.

• save_palettewrite action

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

• select_all

  Select the whole canvas.

• select_rectangle

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

• set_cel_opacity

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

• set_cel_position

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

• set_editor_view

  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.

• set_frame_duration

  Set frame ``number``'s duration in milliseconds.

• set_frame_durations

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

• set_layer_blend_mode

  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.

• set_layer_opacity

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

• set_layer_visibility

  Show or hide a layer.

• set_onion_skin

  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``.)

• set_palette

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

• set_palette_color

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

• set_sprite_metadata

  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.

• set_symmetry

  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.

• sharpen

  Sharpen the active cel (unsharp mask over a 3x3 neighborhood). ``strength`` 0.1-2.0. Only opaque pixels are considered, so sprite edges don't halo against transparency. One undo step.

• show_choice_dialog

  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.

• smear_frame

  Append a motion-smear frame blending ``from_frame`` and ``to_frame``: overlapping pixels averaged, single-frame areas ghosted at half alpha — a pixel-content smear. RGB sprite only. Headless: pass ``file``.

• sort_palette

  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.

• status

  Report backend health plus this server's version and whether a newer release exists. Live: whether Aseprite is connected + its version. Headless: the resolved Aseprite executable path and whether it exists.

• stop_watching_changes

  Detach the ``watch_changes`` listener.

• tween_cel_opacity

  Fade a layer's cels across [from_frame..to_frame]: opacity interpolates from ``from_opacity`` to ``to_opacity`` (0-255) with the chosen easing. Every frame in the range needs a cel on the layer. One undo step.

• tween_frameswrite action

  Insert ``count`` in-between frames between ``from_frame`` and ``to_frame`` that interpolate the cel's position (a motion tween of the start cel's image). ``easing``: linear, ease_in, ease_out, or smoothstep. Headless: pass ``file``.

• undo

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

• watch_changes

  Live editor only: start counting edits the ARTIST makes to the active sprite (via ``Sprite.events``). Poll with ``get_watched_changes`` — e.g. wait for the artist to finish touching up, then re-run the QA sweep.

• Code scan45 source files scanned25/25
• –Live reliabilityno gateway calls yet and no remote to proben/a
• –Tool poisoningtools not inspected (local package is not executed); not countedn/a
• Auth qualitylocal package, no credentials required12/15
• Maintenancelast push 59 days ago12/15
• Maintainer identityregistry namespace matches repository owner6/10

Safety score

85/100

higher than 70% of 48,273 servers

Tools

100

the typical server has 7

Tools that change things

8%

typical: 0%. Fewer write tools means less an agent can break

GitHub stars

7

more than 86% of 28,534 servers

Downloads a week

53

more than 46% of 11,915 servers with a package

Aseprite Live: common questions

Is Aseprite Live MCP server safe?

Yes, by our scan: it is graded A (85/100). Read the Aseprite Live safety report

How do I install Aseprite Live?

It runs on your machine. Copy the Claude Code, Cursor, VS Code or Claude Desktop config from the install section.

Does Aseprite Live need an API key?

No secret keys are declared. It reads 4 settings from the environment.

Is Aseprite Live maintained?

The last commit was 96 days ago (2026-07-29). The latest release is v0.2.0.

How does Aseprite Live compare with other MCP servers?

safety score 85/100 (higher than 70% of 48,273 servers); tools 100 (the typical server has 7); tools that change things 8% (typical: 0%. Fewer write tools means less an agent can break). Full comparison.