# Aseprite Claude Connector (pypi · aseprite-claude-connector)

Let Claude draw in a running Aseprite, and export straight to Godot or Unity

- Trust score: 79/100 (medium)
- Change this week: 0
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- pypi · `aseprite-claude-connector`: 79/100 (this document), [markdown](https://verifymcp.io/servers/umarmuhammad18-aseprite-claude-connector/aseprite-claude-connector.md), [page](https://verifymcp.io/servers/umarmuhammad18-aseprite-claude-connector/aseprite-claude-connector)

## Channel facts

- Registry: `pypi`
- Package: `aseprite-claude-connector`
- Version: `0.4.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs hatchling.build at install time, a recognised build step with no custom scripting around it.
  - 0 of 29 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to UmarMuhammad18/aseprite-claude-connector).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 1 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 77/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 19541 tokens (~101/item across 193 items; 187 tools + 6 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 71/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
  - Structured output schemas are declared (11% of tools); any adoption earns full credit.
- **Tool Safety**: 96/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 6 of 7 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "cancel_ask_point" implies "withdraw" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 189 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the Aseprite Claude Connector MCP server?

Aseprite Claude Connector runs locally as a PyPI package, launched with uvx aseprite-claude-connector. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add umarmuhammad18-aseprite-claude-connector -- uvx aseprite-claude-connector
```

### Cursor

```json
{
  "mcpServers": {
    "umarmuhammad18-aseprite-claude-connector": {
      "command": "uvx",
      "args": [
        "aseprite-claude-connector"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "umarmuhammad18-aseprite-claude-connector": {
      "command": "uvx",
      "args": [
        "aseprite-claude-connector"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add umarmuhammad18-aseprite-claude-connector -- uvx aseprite-claude-connector
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "umarmuhammad18-aseprite-claude-connector": {
      "type": "local",
      "command": [
        "uvx",
        "aseprite-claude-connector"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add umarmuhammad18-aseprite-claude-connector --command uvx --arg aseprite-claude-connector
```

### Hermes

```yaml
mcp_servers:
  umarmuhammad18-aseprite-claude-connector:
    command: "uvx"
    args: ["aseprite-claude-connector"]
```

### Netclaw

```json
{
  "McpServers": {
    "umarmuhammad18-aseprite-claude-connector": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "aseprite-claude-connector"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add umarmuhammad18-aseprite-claude-connector -t stdio -c uvx -a aseprite-claude-connector
```

### Other

```json
{
  "mcpServers": {
    "umarmuhammad18-aseprite-claude-connector": {
      "command": "uvx",
      "args": [
        "aseprite-claude-connector"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-21 (score 79, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-20 (score 64, −15)

- [security regression] Malware scan: pass → unverified

### 2026-11-19 (score 79, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-17 (score 64, −15)

- [security regression] Malware scan: pass → unverified

### 2026-11-13 (score 79, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-12 (score 64)

First indexed and scored.

## MCP tools (187)

### `status` (~50 tokens)

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.

### `get_sprite_info` (~45 tokens)

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

Input parameters:

- `file`

Output parameters:

- `colorMode`
- `filename`
- `frames`
- `height`
- `layers`
- `tags`
- `width`

### `describe_sprite` (~76 tokens)

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.

Input parameters:

- `file`

### `get_pixel` (~49 tokens)

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

Input parameters:

- `file`
- `x` (integer, required)
- `y` (integer, required)

### `set_sprite_metadata` (~77 tokens)

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.

Input parameters:

- `entries` (object, required)
- `file`

### `get_sprite_metadata` (~25 tokens)

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

Input parameters:

- `file`

### `get_pixels` (~91 tokens)

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.

Input parameters:

- `file`
- `height` (integer, required)
- `width` (integer, required)
- `x` (integer, required)
- `y` (integer, required)

### `look` (~213 tokens)

See the canvas: returns a frame as an image, scaled up with sharp pixels.
Defaults to the active frame with all visible layers. ``layer`` shows one
layer or group alone (even if hidden). ``x``/``y``/``width``/``height`` crop
to a region, and ``selection`` crops to the current selection. ``scale`` is
an integer zoom (1-32); omit it to fit ``max_size``. ``background`` is
\``checker``, ``transparent``, or a #rrggbb color. Prefer a crop when you only
need part of the canvas: images use up conversation space. Headless: pass
\``file``.

Input parameters:

- `background` (string)
- `file`
- `frame`
- `height`
- `layer`
- `max_size` (integer)
- `scale`
- `selection` (boolean)
- `width`
- `x`
- `y`

### `look_animation` (~164 tokens)

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``, ``scale``,
\``max_size``, and ``background`` work as in ``look``. Headless: pass
\``file``.

Input parameters:

- `background` (string)
- `columns`
- `file`
- `from_frame`
- `layer`
- `max_size` (integer)
- `scale`
- `tag`
- `to_frame`

### `look_onion` (~120 tokens)

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

Input parameters:

- `background` (string)
- `file`
- `frame`
- `max_size` (integer)
- `next` (integer)
- `opacity` (number)
- `prev` (integer)
- `scale`

### `split_sheet` (~249 tokens)

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 by
default), its background cleared and the bits of neighbouring poses dropped.
Each sprite gets a tag named from ``names`` (row by row; "pose_1"... by
default), so ``pin_sprite(tag=...)`` can pick it. Live: opens the sprites in
the editor. Headless: writes ``<out_dir>/<name>.aseprite``.

Input parameters:

- `clear_edges` (boolean)
- `colors` (integer)
- `columns` (integer, required)
- `dither` (string)
- `height`
- `image_path` (string, required)
- `layer_name` (string)
- `names`
- `out_dir`
- `palette`
- `remove_background` (boolean)
- `rows` (integer, required)
- `width` (integer, required)

### `pixelate_reference` (~380 tokens)

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 picture's
aspect. It is then snapped to ``colors`` colours chosen from the picture, or
to ``palette`` (#rrggbb list) to match an existing one. ``dither`` is
\``none``, ``ordered``, or ``diffusion``. ``despeckle`` removes lone noise
pixels. ``remove_background`` clears a white sheet or flat backdrop (and the
light fringe it leaves), before the palette is chosen so no colours are spent
on it. ``clear_edges`` drops bits of neighbouring art a crop catches at its
edges, keeping the subject and anything floating clear of the edges. To cut
every pose out of a character sheet at once, use ``split_sheet``. Refine the
result by hand, and check it with ``compare_to_reference``. One undo step.
Headless: pass ``file``.

Input parameters:

- `clear_edges` (boolean)
- `colors` (integer)
- `crop_height`
- `crop_width`
- `crop_x`
- `crop_y`
- `despeckle` (boolean)
- `dither` (string)
- `file`
- `height`
- `image_path` (string, required)
- `layer_name` (string)
- `palette`
- `remove_background` (boolean)
- `width` (integer, required)
- `x` (integer)
- `y` (integer)

### `compare_to_reference` (~232 tokens)

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), and
\``close_pixels`` (% that nearly match). ``worst_areas`` are the cells of a
\``grid`` x ``grid`` split that differ most, with both average colours and
whether the art is darker or lighter: fix those first. ``crop_*`` picks the
part of the reference the canvas shows. ``layer`` compares one layer; clear
pixels count as black. Headless: pass ``file``.

Input parameters:

- `crop_height`
- `crop_width`
- `crop_x`
- `crop_y`
- `file`
- `frame`
- `grid` (integer)
- `image_path` (string, required)
- `layer`
- `max_size` (integer)

### `ambient_motion` (~303 tokens)

Bring a still scene to life as a seamless loop. ``layer`` (the active layer
by default) is animated from ``from_frame`` over
\``frames`` frames of ``duration_ms``: ``wind`` (pixels, try 1) sends gusts
rolling left to right, one per ``wavelength`` pixels; ``shimmer`` (pixels)
wobbles rows like water; ``glint`` (0-1) sweeps light across the bright pixels
once a loop. ``particles`` adds a layer of ``motes``, ``snow``, ``rain``, or
\``embers``. Animate each part on its own layer (see ``split_into_layers``) so
armour can glint while grass blows. Frames are added as needed, copying the
others, and tagged ``tag``. Check with ``check_loop``. One undo step.
Headless: pass ``file``.

Input parameters:

- `duration_ms` (integer)
- `file`
- `frames` (integer)
- `from_frame` (integer)
- `glint` (number)
- `glint_color` (string)
- `layer`
- `particle_colors`
- `particle_count` (integer)
- `particles`
- `seed` (integer)
- `shimmer` (number)
- `tag` (string)
- `wavelength` (integer)
- `wind` (number)

### `split_into_layers` (~221 tokens)

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:
\``[{"name": "armour", "x": 90, "y": 40}, {"name": "meadow", "x": 5, "y": 5}]``.
The first part named ends up on top. Each part grows from its seeds and stops where colours change sharply, so
put a seed on every distinct area of a part (a part may have many seeds).
If a part leaks into another, add seeds where it leaked and run it again.
\``layer`` defaults to the active one, which is hidden afterwards unless
\``hide_source`` is false. Check the result with ``look`` and ``layer=``.
One undo step. Headless: pass ``file``.

Input parameters:

- `file`
- `frame`
- `hide_source` (boolean)
- `layer`
- `seeds` (array, required)

### `extend_scene` (~249 tokens)

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 matched
to what is already beside them, so no new colours appear. Pick a sample of
pure background, like open meadow, so the subject isn't copied, and big
enough not to repeat. The margins come from ``frame`` and are shared by the
layer's other frames. Other layers just get a bigger canvas. One undo step. Headless: pass ``file``.

Input parameters:

- `bottom` (integer)
- `file`
- `frame`
- `layer`
- `left` (integer)
- `patch` (integer)
- `right` (integer)
- `sample_height`
- `sample_width`
- `sample_x`
- `sample_y`
- `seed` (integer)
- `top` (integer)

### `clean_pixel_art` (~169 tokens)

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
darker shade. No new colours. ``layer`` defaults to the active one; one
frame, or ``all_frames``. One undo step. Headless: pass ``file``.

Input parameters:

- `all_frames` (boolean)
- `file`
- `firm_edges` (boolean)
- `frame`
- `layer`
- `min_region` (integer)
- `tolerance` (number)

### `draw_eyes` (~426 tokens)

Redraw a character's eyes, frame by frame, to give it an expression:
where it looks, blinks, sleepy or angry lids, a smile. ``eyes`` lists each
eye's socket, the area INSIDE its ring, in canvas pixels: ``{"x": 44, "y":
27.5, "rx": 6.5, "ry": 6.3}``, optionally ``"pupil": [rx, ry]`` (about half
the socket by default), ``"look_scale"`` (0.7 for a far eye in a 3/4 view) and
\``"inner": "left"|"right"`` (the side toward the beak or nose, for brows).
Measure sockets with ``look`` first. ``keys``, one per frame (frames are made
as needed): ``{"frame": 1, "look": [dx, dy], "lid": 0..1, "arc": 0..1,
"brow": -0.6..0.6, "smile": 0..0.6, "closed": false, "ms": 120}``. ``lid``
lowers the upper lid; ``arc`` curves it (relaxed, happy); ``brow`` > 0 slants
it down toward the inner side (angry, focused), < 0 the other way (worried,
sad); ``smile`` pushes up a lower lid; ``closed`` shuts the eye. Expression is
easy to misread: when unsure, draw 3-4 options and ask. Colours come from the
eyes already there; pass the returned ``style`` back on every sprite of the
same character so all its eyes match. The area round each eye is repainted
in skin colour. One undo step. Headless: pass ``file``.

Input parameters:

- `eyes` (array, required)
- `file`
- `keys`
- `layer`
- `style`

### `swing_part` (~239 tokens)

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.
\``keys``, one per frame (frames are made as needed): ``{"frame": 2,
"angle": 10, "dx": 0, "dy": -1, "ms": 90}``, angle in degrees clockwise.
Where the part met the body, a ``band`` of ``shadow`` (the part's darkest
colour by default) stays underneath, so turning never opens a gap, and the
part's light outer halo is dropped so it doesn't streak. Small angles (up to
about 15) look best. One undo step. Headless: pass ``file``.

Input parameters:

- `band` (integer)
- `file`
- `keys` (array, required)
- `layer`
- `outline` (array, required)
- `pivot` (array, required)
- `shadow`

### `bob_body` (~161 tokens)

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.
\``keys``, one per frame (frames are made as needed): ``{"frame": 1, "dy":
\-1, "dx": 0, "ms": 160}``; -1 rises a pixel (the legs stretch), +1 sinks.
Breathing is 0/-1; a hop -2..-4; a sway dx -1/+1. One undo step. Headless:
pass ``file``.

Input parameters:

- `feet_y` (integer, required)
- `file`
- `keys` (array, required)
- `layer`

### `lift_symbols` (~208 tokens)

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 erased from
every frame of ``layer``. ``keys``, one per frame (frames are made as
needed): ``{"frame": 2, "symbols": [[dx, dy], null], "ms": 100}``, an offset
per box, or null to hide it. Frames without a key show them in place. One
undo step. Headless: pass ``file``.

Input parameters:

- `boxes` (array, required)
- `file`
- `from_frame` (integer)
- `keys`
- `layer`
- `name` (string)

### `check_consistency` (~145 tokens)

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 each, so differences in scale show.
Close colours every sprite uses side by side are shading steps, not drift.
Poses lying down or crouching are shorter by nature. Fix colours with
\``match_palettes``. Read-only.

Input parameters:

- `files`
- `only`
- `tolerance` (number)

### `match_palettes` (~114 tokens)

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 kept. One undo step per sprite. Check
first with ``check_consistency``.

Input parameters:

- `files`
- `only`
- `tolerance` (number)

### `animate_parts` (~321 tokens)

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 ``smooth``
or ``linear``), and with ``loop`` the last pose eases back to the first.
\``pivots`` maps a part to the [x, y] it turns about (a shoulder, a hip; its
middle by default). ``parents`` maps a part to the one it hangs from, so
\``{"Forearm": "Arm"}`` keeps the forearm on the arm. Each part is drawn from
its ``from_frame`` pixels, turned with RotSprite-style rotation so edges stay
crisp. Frames are added as needed and tagged ``tag``. Check the result with
\``look_animation`` and ``check_loop``. One undo step. Headless: pass
\``file``.

Input parameters:

- `duration_ms` (integer)
- `easing` (string)
- `file`
- `frames` (integer, required)
- `from_frame` (integer)
- `loop` (boolean)
- `parents`
- `pivots`
- `poses` (array, required)
- `tag` (string)

### `relight_scene` (~208 tokens)

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], ...]``, whose
pools stay warm and lit. ``strength`` (0-1) blends toward the original.
Works on ``layers`` (every visible image layer by default), writing a copy
named like "Ground (night)" above each and hiding the original, so switching
back is a visibility toggle. One undo step. Headless: pass ``file``.

Input parameters:

- `all_frames` (boolean)
- `file`
- `glows`
- `layers`
- `strength` (number)
- `time` (string, required)

### `make_normal_map` (~221 tokens)

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 ``save_path``
also writes it as a PNG strip matching an exported sprite sheet (frames side
by side). In Godot, set it as the normal map of a CanvasTexture whose diffuse
is the sprite; in Unity, add it to the sprite's Secondary Textures as
\``_NormalMap``. Made from ``layer``, or everything visible by default.
One undo step. Headless: pass ``file``.

Input parameters:

- `all_frames` (boolean)
- `bevel` (integer)
- `detail` (number)
- `file`
- `layer`
- `save_path`
- `strength` (number)

### `make_seamless` (~159 tokens)

Make a texture repeat with no visible edge, for ground, walls, or water
tiles. The layer (the active one by default) fills the canvas: it is shifted
by half so its old edges meet in the middle, and that cross, ``band`` pixels
wide (an eighth of the size by default), is rebuilt from ``patch``-sized
pieces of the texture itself. Check it with ``look`` after
\``expand_canvas`` or by exporting a few side by side. One undo step.
Headless: pass ``file``.

Input parameters:

- `band`
- `file`
- `frame`
- `layer`
- `patch` (integer)
- `seed` (integer)

### `make_autotiles` (~301 tokens)

Build the 47-tile autotile set for one terrain (``fill_layer``, like
grass) over another (``base_layer``, like dirt, or clear), so a map painter
picks the right edge and corner for every neighbour. Both textures come from
the top-left ``size`` square of their layer, so ``make_seamless`` them first.
\``edge`` is how far the fill stops from an open side, and ``outline`` gives
its border a darker shade of its own colours.
Writes ``name``.png. With ``game_dir`` (or the remembered game folder, if
\``out_dir`` isn't given), a Godot project also gets ``name``.tres, a TileSet
whose terrain paints the set, and a Unity project gets the sheet sliced into
tiles plus ``name``_rule.asset, a Rule Tile (needs the 2D Tilemap Extras
package). ``out_dir`` writes the PNG and a JSON map of each tile's
neighbours. Returns a picture of the set. Headless: pass ``file``.

Input parameters:

- `base_layer`
- `edge`
- `file`
- `fill_layer` (string, required)
- `frame` (integer)
- `game_dir`
- `name` (string, required)
- `out_dir`
- `outline` (boolean)
- `size` (integer, required)

### `export_animation` (~152 tokens)

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 by
default), as are both when it's given. Written from Python, so the live
editor shows no security prompt. Headless: pass ``file``.

Input parameters:

- `background`
- `file`
- `path` (string, required)
- `scale` (integer)
- `tag`

### `clean_lines` (~158 tokens)

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.
\``specks`` also clears pixels with no neighbour. Kept pixels keep their
colour. Use it on a line-art layer over transparency (``layer``, the active
one by default); one frame, or ``all_frames``. One undo step. Headless: pass
\``file``.

Input parameters:

- `all_frames` (boolean)
- `file`
- `frame`
- `layer`
- `specks` (boolean)
- `thin` (boolean)

### `search_api_docs` (~72 tokens)

Search Aseprite's Lua scripting API reference, bundled with this server.
Use it before writing ``run_lua`` code, for a class, method, or property such
as ``Image:drawImage`` or ``selection bounds``.

Input parameters:

- `limit` (integer)
- `query` (string, required)

### `search_manual` (~73 tokens)

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.

Input parameters:

- `limit` (integer)
- `query` (string, required)

### `set_safety_rails` (~130 tokens)

Set the safety rails for this session, or pass nothing to read them.
\``dry_run`` true makes every edit report what it would change, as an error,
then roll back; tools that save, export, or run raw Lua refuse instead.
\``max_changed_pixels`` caps what one call can change, and an edit over it is
rolled back; 0 removes the cap. It counts hidden layers. ``move_layer`` isn't capped, and
\``run_lua`` is capped only with ``edit=true``.

Input parameters:

- `dry_run`
- `max_changed_pixels`

### `edit_batch` (~118 tokens)

Run several editing tools as one undo step, so one Ctrl-Z reverts them all.
Each step is ``{"tool": "draw_line", "args": {...}}``, in order. If any step
fails, none of them apply. The pixel cap covers the whole batch. Steps can't
see each other's results, and tools that save or export can't be batched.
Headless: pass ``file`` here, not in the steps.

Input parameters:

- `file`
- `label` (string)
- `steps` (array, required)

### `edit_in_selection` (~126 tokens)

"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 selected. Steps can't change the
frames, layers, or canvas size. Headless: pass ``file`` here, not in the steps.

Input parameters:

- `file`
- `label` (string)
- `steps` (array, required)

### `open_sprite` (~112 tokens)

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 — to
edit a file headless, pass it as the ``file`` argument of the editing
tools instead.

Input parameters:

- `path` (string, required)

### `save_sprite` (~126 tokens)

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 own; use this with both arguments to write a
copy of ``file`` under a new ``path`` (the source file on disk stays
untouched).

Input parameters:

- `file`
- `path`

### `close_sprite` (~72 tokens)

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.

Input parameters:

- `force` (boolean)

### `set_active_sprite` (~87 tokens)

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

Input parameters:

- `filename` (string, required)

### `pin_sprite` (~131 tokens)

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 ("work on this one"). ``unpin`` goes back to following whichever sprite
is active. Sprites Claude creates or opens are pinned on their own.

Input parameters:

- `filename`
- `tag`
- `unpin` (boolean)

### `save_all_sprites` (~139 tokens)

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
untouched. ``all_sprites`` copies unchanged ones too. ``only`` limits it to
sprites with these filenames or tags. Never overwrites: a taken name gets a
number.

Input parameters:

- `all_sprites` (boolean)
- `folder` (string, required)
- `only`

### `list_sprites` (~66 tokens)

Live editor only: list every open document — filename (or
"(unsaved)"), size, frame/layer counts, tags, unsaved-changes flag, which
one is active in the editor, and which one Claude's edits go to
(``pinned``).

### `create_sprite` (~98 tokens)

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.
Headless: writes a new .aseprite to ``file`` (required).
\``color_mode`` is one of rgb | gray | indexed.

Input parameters:

- `color_mode` (string)
- `file`
- `height` (integer, required)
- `width` (integer, required)

### `expand_canvas` (~82 tokens)

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

Input parameters:

- `bottom` (integer)
- `file`
- `left` (integer)
- `right` (integer)
- `top` (integer)

### `import_spritesheet` (~103 tokens)

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

Input parameters:

- `file`
- `frame_height` (integer, required)
- `frame_width` (integer, required)
- `sheet_path` (string, required)

### `add_layer` (~35 tokens)

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

Input parameters:

- `file`
- `name`

### `add_group` (~49 tokens)

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

Input parameters:

- `file`
- `name`

### `move_layer_to_group` (~37 tokens)

Move a layer inside a layer group.

Input parameters:

- `file`
- `group` (string, required)
- `layer` (string, required)

### `list_layers` (~60 tokens)

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

Input parameters:

- `file`

### `delete_layer` (~28 tokens)

Delete the layer with the given name.

Input parameters:

- `file`
- `name` (string, required)

### `rename_layer` (~33 tokens)

Rename a layer.

Input parameters:

- `file`
- `new_name` (string, required)
- `old_name` (string, required)

### `set_layer_visibility` (~34 tokens)

Show or hide a layer.

Input parameters:

- `file`
- `name` (string, required)
- `visible` (boolean, required)

### `set_layer_opacity` (~39 tokens)

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

Input parameters:

- `file`
- `name` (string, required)
- `opacity` (integer, required)

### `flatten_sprite` (~21 tokens)

Flatten all layers into a single layer.

Input parameters:

- `file`

### `set_layer_blend_mode` (~88 tokens)

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.

Input parameters:

- `file`
- `mode` (string, required)
- `name` (string, required)

### `duplicate_layer` (~33 tokens)

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

Input parameters:

- `file`
- `name` (string, required)

### `merge_layer_down` (~31 tokens)

Merge a layer into the layer directly beneath it.

Input parameters:

- `file`
- `name` (string, required)

### `move_layer` (~54 tokens)

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

Input parameters:

- `direction` (string, required)
- `file`
- `name` (string, required)

### `import_image_as_layer` (~88 tokens)

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

Input parameters:

- `file`
- `image_path` (string, required)
- `layer_name`
- `x` (integer)
- `y` (integer)

### `add_frame` (~19 tokens)

Append a new empty frame.

Input parameters:

- `file`

### `duplicate_frame` (~29 tokens)

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

Input parameters:

- `file`
- `number` (integer, required)

### `delete_frame` (~35 tokens)

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

Input parameters:

- `file`
- `number` (integer, required)

### `set_frame_duration` (~39 tokens)

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

Input parameters:

- `file`
- `ms` (integer, required)
- `number` (integer, required)

### `add_frames` (~31 tokens)

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

Input parameters:

- `count` (integer, required)
- `file`

### `set_frame_durations` (~55 tokens)

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

Input parameters:

- `file`
- `from_frame` (integer, required)
- `ms` (integer, required)
- `to_frame` (integer, required)

### `reverse_frames` (~63 tokens)

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.

Input parameters:

- `file`
- `from_frame`
- `to_frame`

### `set_onion_skin` (~109 tokens)

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

Input parameters:

- `active` (boolean, required)
- `file`
- `loop_tag`
- `next_frames` (integer)
- `prev_frames` (integer)

### `clear_cel` (~36 tokens)

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

Input parameters:

- `file`
- `frame`
- `layer`

### `set_cel_position` (~52 tokens)

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

Input parameters:

- `file`
- `frame`
- `layer`
- `x` (integer, required)
- `y` (integer, required)

### `set_cel_opacity` (~43 tokens)

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

Input parameters:

- `file`
- `frame`
- `layer`
- `opacity` (integer, required)

### `draw_pixels` (~119 tokens)

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

\``preview`` true also returns a before/after picture of the canvas with the changed-pixel count and bbox.

Input parameters:

- `file`
- `pixels` (array, required)
- `preview` (boolean)

Output parameters:

- `result` (object)

### `draw_polyline` (~107 tokens)

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

\``preview`` true also returns a before/after picture of the canvas with the changed-pixel count and bbox.

Input parameters:

- `close` (boolean)
- `color` (string, required)
- `file`
- `points` (array, required)
- `preview` (boolean)

Output parameters:

- `result` (object)

### `draw_rectangle` (~133 tokens)

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

\``preview`` true also returns a before/after picture of the canvas with the changed-pixel count and bbox.

Input parameters:

- `color` (string, required)
- `file`
- `fill` (boolean)
- `height` (integer, required)
- `preview` (boolean)
- `width` (integer, required)
- `x` (integer, required)
- `y` (integer, required)

Output parameters:

- `result` (object)

### `draw_line` (~113 tokens)

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

\``preview`` true also returns a before/after picture of the canvas with the changed-pixel count and bbox.

Input parameters:

- `color` (string, required)
- `file`
- `preview` (boolean)
- `x1` (integer, required)
- `x2` (integer, required)
- `y1` (integer, required)
- `y2` (integer, required)

Output parameters:

- `result` (object)

### `draw_circle` (~112 tokens)

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

\``preview`` true also returns a before/after picture of the canvas with the changed-pixel count and bbox.

Input parameters:

- `center_x` (integer, required)
- `center_y` (integer, required)
- `color` (string, required)
- `file`
- `fill` (boolean)
- `preview` (boolean)
- `radius` (integer, required)

Output parameters:

- `result` (object)

### `fill_area` (~95 tokens)

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

\``preview`` true also returns a before/after picture of the canvas with the changed-pixel count and bbox.

Input parameters:

- `color` (string, required)
- `file`
- `preview` (boolean)
- `x` (integer, required)
- `y` (integer, required)

Output parameters:

- `result` (object)

### `draw_ellipse` (~127 tokens)

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

\``preview`` true also returns a before/after picture of the canvas with the changed-pixel count and bbox.

Input parameters:

- `center_x` (integer, required)
- `center_y` (integer, required)
- `color` (string, required)
- `file`
- `fill` (boolean)
- `preview` (boolean)
- `radius_x` (integer, required)
- `radius_y` (integer, required)

Output parameters:

- `result` (object)

### `draw_gradient` (~215 tokens)

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. With ``dither``, ``bands`` above 1 steps through that
many solid colors and dithers only the seams, which reads far cleaner than one
dither across a tall area. One undo step. Headless: pass ``file``.

\``preview`` true also returns a before/after picture of the canvas with the changed-pixel count and bbox.

Input parameters:

- `bands` (integer)
- `color1` (string, required)
- `color2` (string, required)
- `direction` (string)
- `dither` (boolean)
- `file`
- `height` (integer, required)
- `preview` (boolean)
- `width` (integer, required)
- `x` (integer, required)
- `y` (integer, required)

Output parameters:

- `result` (object)

### `apply_dither` (~163 tokens)

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

\``preview`` true also returns a before/after picture of the canvas with the changed-pixel count and bbox.

Input parameters:

- `color1` (string, required)
- `color2` (string, required)
- `density` (number)
- `file`
- `height` (integer, required)
- `preview` (boolean)
- `width` (integer, required)
- `x` (integer, required)
- `y` (integer, required)

Output parameters:

- `result` (object)

### `add_outline` (~188 tokens)

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 diagonally (8-connected). ``layer``
picks the layer, and ``all_frames`` outlines every cel on it rather than the
active one. One undo step. Headless: pass ``file``.

\``preview`` true also returns a before/after picture of the canvas with the changed-pixel count and bbox.

Input parameters:

- `all_frames` (boolean)
- `color` (string)
- `diagonal` (boolean)
- `file`
- `layer`
- `preview` (boolean)
- `selective` (boolean)

Output parameters:

- `result` (object)

### `get_palette` (~28 tokens)

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

Input parameters:

- `file`

### `set_palette_color` (~49 tokens)

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

Input parameters:

- `color` (string, required)
- `file`
- `index` (integer, required)

### `add_palette_color` (~34 tokens)

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

Input parameters:

- `color` (string, required)
- `file`

### `set_palette` (~41 tokens)

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

Input parameters:

- `colors` (array, required)
- `file`

### `apply_preset_palette` (~40 tokens)

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

Input parameters:

- `file`
- `name` (string, required)

### `generate_color_ramp` (~108 tokens)

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

Input parameters:

- `base_color` (string, required)
- `count` (integer)
- `file`
- `hue_shift` (boolean)

### `extract_palette_from_image` (~92 tokens)

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

Input parameters:

- `file`
- `image_path` (string, required)
- `max_colors` (integer)
- `replace` (boolean)

### `sort_palette` (~86 tokens)

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.

Input parameters:

- `ascending` (boolean)
- `by` (string)
- `file`

### `palette_from_sprite` (~65 tokens)

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.

Input parameters:

- `file`
- `max_colors` (integer)

### `load_palette` (~52 tokens)

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

Input parameters:

- `file`
- `path` (string, required)

### `save_palette` (~41 tokens)

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

Input parameters:

- `file`
- `path` (string, required)

### `apply_bundled_palette` (~83 tokens)

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.

Input parameters:

- `file`
- `name` (string, required)

### `replace_color` (~97 tokens)

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

Input parameters:

- `file`
- `from_color` (string, required)
- `to_color` (string, required)
- `tolerance` (integer)

### `quantize_to_palette` (~62 tokens)

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

Input parameters:

- `file`

### `adjust_hsl` (~99 tokens)

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

Input parameters:

- `file`
- `hue_shift` (number)
- `lightness` (number)
- `saturation` (number)

### `get_color_stats` (~75 tokens)

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

Input parameters:

- `file`
- `top` (integer)

### `apply_shading` (~109 tokens)

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

Input parameters:

- `file`
- `height` (integer, required)
- `intensity` (number)
- `light_direction` (string, required)
- `width` (integer, required)
- `x` (integer, required)
- `y` (integer, required)

### `palette_ramp_walk` (~135 tokens)

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;
one undo step. Headless: pass ``file``.

Input parameters:

- `file`
- `height` (integer, required)
- `light_direction` (string, required)
- `steps` (integer)
- `width` (integer, required)
- `x` (integer, required)
- `y` (integer, required)

### `adjust_brightness_contrast` (~66 tokens)

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

Input parameters:

- `brightness` (integer)
- `contrast` (integer)
- `file`

### `invert_colors` (~28 tokens)

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

Input parameters:

- `file`

### `desaturate` (~43 tokens)

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

Input parameters:

- `file`

### `box_blur` (~60 tokens)

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

Input parameters:

- `file`
- `radius` (integer)

### `sharpen` (~67 tokens)

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.

Input parameters:

- `file`
- `strength` (number)

### `paint_with_stamp` (~138 tokens)

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

\``preview`` true also returns a before/after picture of the canvas with the changed-pixel count and bbox.

Input parameters:

- `file`
- `layer`
- `points` (array, required)
- `preview` (boolean)
- `source_path`
- `source_rect`

Output parameters:

- `result` (object)

### `draw_iso_box` (~188 tokens)

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

\``preview`` true also returns a before/after picture of the canvas with the changed-pixel count and bbox.

Input parameters:

- `center_x` (integer, required)
- `center_y` (integer, required)
- `color` (string, required)
- `file`
- `half_width` (integer, required)
- `height` (integer, required)
- `preview` (boolean)

Output parameters:

- `result` (object)

### `draw_iso_cylinder` (~137 tokens)

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

\``preview`` true also returns a before/after picture of the canvas with the changed-pixel count and bbox.

Input parameters:

- `center_x` (integer, required)
- `color` (string, required)
- `file`
- `height` (integer, required)
- `preview` (boolean)
- `radius` (integer, required)
- `top_y` (integer, required)

Output parameters:

- `result` (object)

### `fill_polygon` (~107 tokens)

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

\``preview`` true also returns a before/after picture of the canvas with the changed-pixel count and bbox.

Input parameters:

- `color` (string, required)
- `file`
- `points` (array, required)
- `preview` (boolean)

Output parameters:

- `result` (object)

### `iso_recessed_panel` (~131 tokens)

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

\``preview`` true also returns a before/after picture of the canvas with the changed-pixel count and bbox.

Input parameters:

- `file`
- `points` (array, required)
- `preview` (boolean)

Output parameters:

- `result` (object)

### `select_rectangle` (~53 tokens)

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

Input parameters:

- `file`
- `height` (integer, required)
- `width` (integer, required)
- `x` (integer, required)
- `y` (integer, required)

### `select_all` (~18 tokens)

Select the whole canvas.

Input parameters:

- `file`

### `deselect` (~18 tokens)

Clear the current selection.

Input parameters:

- `file`

### `select_ellipse` (~84 tokens)

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

Input parameters:

- `file`
- `height` (integer, required)
- `mode` (string)
- `width` (integer, required)
- `x` (integer, required)
- `y` (integer, required)

### `select_by_color` (~83 tokens)

Select every pixel matching ``color`` (composited, within
\``tolerance`` 0-255 per channel) — a global magic wand. ``mode`` is
\``replace``/``add``/``subtract``.

Input parameters:

- `color` (string, required)
- `file`
- `mode` (string)
- `tolerance` (integer)

### `invert_selection` (~23 tokens)

Invert the current selection against the canvas bounds.

Input parameters:

- `file`

### `get_selection` (~50 tokens)

Report whether a selection exists and its bounding rectangle.
(Selection is editor-session state — in headless mode it doesn't persist
between calls, so this is mainly a live-editor tool.)

Input parameters:

- `file`

### `erase_area` (~74 tokens)

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.

Input parameters:

- `file`
- `height`
- `width`
- `x`
- `y`

### `flip_sprite` (~28 tokens)

Flip the whole sprite horizontally or vertically.

Input parameters:

- `direction` (string, required)
- `file`

### `resize_sprite` (~36 tokens)

Scale the whole sprite to new pixel dimensions.

Input parameters:

- `file`
- `height` (integer, required)
- `width` (integer, required)

### `crop_sprite` (~49 tokens)

Crop the sprite to the given rectangle.

Input parameters:

- `file`
- `height` (integer, required)
- `width` (integer, required)
- `x` (integer, required)
- `y` (integer, required)

### `rotate_sprite` (~52 tokens)

Rotate the whole sprite by 90, 180, or 270 degrees clockwise (lossless).
One undo step. Headless: pass ``file``.

Input parameters:

- `degrees` (integer, required)
- `file`

### `autocrop_sprite` (~67 tokens)

Trim transparent borders: shrink the canvas to the union of visible
content across all layers and frames (Sprite > Trim). Errors if the
sprite is fully transparent. Returns the old and new size. One undo
step. Headless: pass ``file``.

Input parameters:

- `file`

### `set_color_mode` (~83 tokens)

Convert the sprite between rgb | gray | indexed color modes.
\``dithering`` applies only when converting to indexed: ordered | old |
error-diffusion (default none). Returns the old and new mode. One undo
step. Headless: pass ``file``.

Input parameters:

- `dithering`
- `file`
- `mode` (string, required)

### `create_slice` (~86 tokens)

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

Input parameters:

- `file`
- `height` (integer, required)
- `name` (string, required)
- `width` (integer, required)
- `x` (integer, required)
- `y` (integer, required)

### `set_slice_pivot` (~87 tokens)

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

Input parameters:

- `file`
- `name` (string, required)
- `pivot_x` (integer, required)
- `pivot_y` (integer, required)

### `set_slice_center` (~79 tokens)

Set a slice's 9-patch stretchable center rectangle (relative to the slice).
One undo step. Headless: pass ``file``.

Input parameters:

- `file`
- `height` (integer, required)
- `name` (string, required)
- `width` (integer, required)
- `x` (integer, required)
- `y` (integer, required)

### `list_slices` (~41 tokens)

List every slice with its bounds, pivot, and 9-patch center. Read-only.
Headless: pass ``file``.

Input parameters:

- `file`

### `delete_slice` (~40 tokens)

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

Input parameters:

- `file`
- `name` (string, required)

### `create_tag` (~59 tokens)

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

Input parameters:

- `file`
- `from_frame` (integer, required)
- `name` (string, required)
- `to_frame` (integer, required)

### `delete_tag` (~29 tokens)

Delete the animation tag named ``name``.

Input parameters:

- `file`
- `name` (string, required)

### `list_tags` (~21 tokens)

List animation tags with their frame ranges.

Input parameters:

- `file`

### `rename_tag` (~55 tokens)

Rename the animation tag ``old_name`` to ``new_name``. One undo step.
Headless: pass ``file``.

Input parameters:

- `file`
- `new_name` (string, required)
- `old_name` (string, required)

### `set_tag_color` (~63 tokens)

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

Input parameters:

- `color` (string, required)
- `file`
- `name` (string, required)

### `set_tag_range` (~83 tokens)

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

Input parameters:

- `file`
- `from_frame` (integer, required)
- `name` (string, required)
- `to_frame` (integer, required)

### `set_tag_direction` (~62 tokens)

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

Input parameters:

- `direction` (string, required)
- `file`
- `name` (string, required)

### `create_tilemap_layer` (~95 tokens)

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

Input parameters:

- `file`
- `name` (string, required)
- `tile_height` (integer, required)
- `tile_width` (integer, required)

### `add_tile` (~77 tokens)

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

Input parameters:

- `file`
- `layer` (string, required)

### `draw_on_tile` (~120 tokens)

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

Input parameters:

- `file`
- `layer` (string, required)
- `pixels` (array, required)
- `tile_index` (integer, required)

### `set_tiles` (~113 tokens)

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.
\``frame`` is 1-based. One undo step. Headless: pass ``file``.

Input parameters:

- `file`
- `frame` (integer, required)
- `layer` (string, required)
- `tiles` (array, required)

### `get_tilemap_info` (~96 tokens)

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

Input parameters:

- `file`
- `frame` (integer)
- `layer` (string, required)

### `export_tileset` (~116 tokens)

Export a tilemap layer's tileset as a horizontal PNG strip (plus an
Aseprite JSON atlas if ``data_path`` is given). The strip includes tile 0
(the empty tile) first, so tile index i sits at x = i * tile_width. Writes
files but does not modify the sprite (it does make the layer active).
Headless: pass ``file``.

Input parameters:

- `data_path`
- `file`
- `layer` (string, required)
- `output_path` (string, required)

### `tween_frames` (~152 tokens)

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``: linear,
ease_in, ease_out, or smoothstep. Check the result with ``look_animation``.
Headless: pass ``file``.

Input parameters:

- `count` (integer)
- `easing` (string)
- `file`
- `from_frame` (integer, required)
- `layer`
- `to_frame` (integer, required)

### `tween_cel_opacity` (~121 tokens)

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.

Input parameters:

- `easing` (string)
- `file`
- `from_frame` (integer, required)
- `from_opacity` (integer, required)
- `layer`
- `to_frame` (integer, required)
- `to_opacity` (integer, required)

### `smear_frame` (~83 tokens)

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

Input parameters:

- `file`
- `from_frame` (integer, required)
- `layer`
- `to_frame` (integer, required)

### `frame_diff` (~89 tokens)

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

Input parameters:

- `file`
- `frame_a` (integer, required)
- `frame_b` (integer, required)

### `render_onion_composite` (~130 tokens)

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

Input parameters:

- `file`
- `frame` (integer, required)
- `next` (integer)
- `opacity` (number)
- `output_path` (string, required)
- `prev` (integer)

### `inbetween` (~189 tokens)

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. ``smear`` makes the
middle frame hold both poses at once, for fast moves. Other layers hold still.
It's a first pass to draw over, not finished art. ``easing``: linear, ease_in,
ease_out, or smoothstep. One undo step. Headless: pass ``file``.

Input parameters:

- `count` (integer)
- `easing` (string)
- `file`
- `from_frame` (integer, required)
- `layer`
- `max_size` (integer)
- `smear` (boolean)

### `walk_cycle_template` (~186 tokens)

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 dark blue. Feet travel
backward on the ground and swing forward through the air, so the cycle walks
forward; the figure stays in place, ready for scrolling scenery or game movement.
Check it with ``look_animation``, then hide or delete the guide. One undo step.
Headless: pass ``file``.

Input parameters:

- `body_height` (integer, required)
- `facing` (string)
- `file`
- `frames` (integer)
- `gait` (string)
- `tag`

### `apply_timing` (~161 tokens)

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. ``base_ms`` is the quickest frame
and ``strength`` how many times longer the slowest lasts. One undo step. Headless:
pass ``file``.

Input parameters:

- `base_ms` (integer)
- `file`
- `from_frame`
- `preset` (string, required)
- `strength` (number)
- `tag`
- `to_frame`

### `check_loop` (~135 tokens)

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 crop with ``look``.
Compares up to 12 steps from long animations. Read-only. Headless: pass
\``file``.

Input parameters:

- `file`
- `from_frame`
- `tag`
- `to_frame`

### `export_sprite` (~130 tokens)

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. Headless: pass ``file``.

Input parameters:

- `file`
- `out_path` (string, required)

### `export_spritesheet` (~90 tokens)

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

Input parameters:

- `data_path`
- `file`
- `out_path` (string, required)
- `sheet_type` (string)

### `export_layers` (~126 tokens)

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: pass ``file``.

Input parameters:

- `file`
- `out_dir` (string, required)

### `export_tags` (~115 tokens)

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

Input parameters:

- `file`
- `format` (string)
- `out_dir` (string, required)

### `export_unity_sprite` (~170 tokens)

Export a horizontal sprite sheet AND write the Unity ``.meta`` beside it,
pre-sliced into named Multiple-mode sprites (one per frame) — one action, no
manual Sprite Editor pass. ``alignment`` is one of center, top_left, top,
top_right, left, right, bottom_left, bottom, bottom_right, custom; ``custom``
uses ``pivot_x``/``pivot_y`` (0..1, 0,0 = bottom left). Targets Unity 2021.3+/6.
Headless: pass ``file``.

Input parameters:

- `alignment` (string)
- `file`
- `pivot_x` (number)
- `pivot_y` (number)
- `pixels_per_unit` (integer)
- `png_path` (string, required)

Output parameters:

- `alignment`
- `frame_size`
- `frames`
- `guid`
- `meta`
- `mode`
- `pixels_per_unit`
- `png`
- `png_exists`
- `sheet_size`
- `sprites`
- `texture_size`

### `export_unity_slices` (~118 tokens)

Export the sprite as a single PNG AND write a Unity ``.meta`` with one
Multiple-mode sprite **per named slice**, each carrying that slice's pivot —
so an atlas laid out with slices imports into Unity already sliced *and*
pivoted. No competitor's Aseprite→Unity path exports pivots. Requires slices
(see create_slice / set_slice_pivot). Headless: pass ``file``.

Input parameters:

- `file`
- `pixels_per_unit` (integer)
- `png_path` (string, required)

Output parameters:

- `alignment`
- `frame_size`
- `frames`
- `guid`
- `meta`
- `mode`
- `pixels_per_unit`
- `png`
- `png_exists`
- `sheet_size`
- `sprites`
- `texture_size`

### `export_godot` (~147 tokens)

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 out
from ``project.godot``; otherwise ``project_found`` is false and the file must
sit at the project root. For sharp pixels, set the node's Texture Filter to
Nearest. Headless: pass ``file``.

Input parameters:

- `file`
- `png_path` (string, required)

### `export_to_game` (~209 tokens)

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 sheet.
Art goes in the project's existing sprites or assets folder, or a new
\``sprites`` (``Assets/Sprites`` in Unity). Godot gets a PNG, plus a
\``SpriteFrames`` ``.tres`` if animated. Unity gets a PNG and a pre-sliced
\``.meta``, using ``pixels_per_unit``, and exporting again keeps the references
to it working. ``name`` defaults to the sprite's file name. Headless: pass
\``file``.

Input parameters:

- `file`
- `game_dir`
- `name`
- `pixels_per_unit` (integer)

### `export_gamemaker` (~122 tokens)

Write sprite strips GameMaker cuts up by itself: one
\``<name>_<tag>_stripN.png`` per tag, or ``<name>_stripN.png`` with no tags. Drag
them into GameMaker, or import them in its sprite editor. GameMaker gives a sprite
one speed, so the result lists each strip's ``fps`` to enter there, and flags
uneven timing. Headless: pass ``file``.

Input parameters:

- `file`
- `name`
- `output_dir` (string, required)

### `pack_atlas` (~131 tokens)

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 beside the PNG unless
\``out_json`` says otherwise, and frames are keyed ``<sprite> <index>``.

Input parameters:

- `out_json`
- `out_png` (string, required)
- `padding` (integer)
- `sprites` (array, required)

### `measure_padding` (~61 tokens)

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

Input parameters:

- `file`

Output parameters:

- `canvas`
- `colorCount`
- `content`
- `empty`
- `fillRatio`
- `padding`

### `qa_sweep` (~139 tokens)

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

Input parameters:

- `expected_height`
- `expected_width`
- `file`
- `grid_multiple`
- `max_colors`
- `require_symmetric_padding` (boolean)

Output parameters:

- `checks`
- `failed`
- `measurements`
- `passed`

### `find_stray_pixels` (~184 tokens)

Find pixels and colors that look like accidents, and return a picture of
them: the art in gray, with floating ``isolated`` pixels in red, ``orphan``
pixels (touching art but matching none of it) in yellow, and pixels of colors
used ``rare`` times or fewer in magenta. Also lists ``near_duplicates``: colors
within ``near`` of a much commoner one. Dithering and highlights can be
deliberate orphans, so treat this as a list to look over, not to erase. Defaults
to the active frame, all visible layers. Read-only. Headless: pass ``file``.

Input parameters:

- `file`
- `frame`
- `layer`
- `max_size` (integer)
- `near` (integer)
- `rare` (integer)

### `recolor_variants` (~177 tokens)

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 returns a picture comparing
them. Colors must match exactly, and any that were never found are listed in
\``unmatched``. Leaves the sprite untouched. ``tag`` limits it to one animation.
Headless: pass ``file``.

Input parameters:

- `file`
- `name`
- `output_dir` (string, required)
- `tag`
- `variants` (object, required)

### `add_reference_image` (~158 tokens)

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.
\``image_path`` is a file on disk; a picture pasted into chat needs saving first.
\``fit`` shrinks a larger image to the canvas. ``opacity`` is 0-255. Hide or delete
the layer when done. Saving to a flat format would merge it in, so hide it first.
One undo step. Headless: pass ``file``.

Input parameters:

- `file`
- `fit` (boolean)
- `image_path` (string, required)
- `layer_name` (string)
- `opacity` (integer)

### `change_summary` (~104 tokens)

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, and frames are missing
for edits made with the pixel cap off, or that can't lose pixels.

Input parameters:

- `last`

### `explain_changes` (~64 tokens)

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.

Input parameters:

- `last` (integer)

### `start_recording` (~92 tokens)

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

Input parameters:

- `file`
- `max_frames` (integer)

### `stop_recording` (~92 tokens)

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.

Input parameters:

- `frame_ms` (integer)
- `max_size` (integer)
- `out_path` (string, required)

### `batch_export` (~131 tokens)

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

Input parameters:

- `file`
- `folder` (string, required)
- `format` (string)
- `out_dir`
- `recursive` (boolean)
- `scale` (integer)

### `batch_resize` (~117 tokens)

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.

Input parameters:

- `file`
- `folder` (string, required)
- `format` (string)
- `height`
- `out_dir`
- `recursive` (boolean)
- `scale`
- `width`

### `batch_apply_palette` (~127 tokens)

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.

Input parameters:

- `file`
- `folder` (string, required)
- `format` (string)
- `out_dir`
- `palette`
- `preset`
- `recursive` (boolean)

### `select_frame` (~55 tokens)

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.

Input parameters:

- `file`
- `number` (integer, required)

### `select_layer` (~69 tokens)

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.

Input parameters:

- `file`
- `name` (string, required)

### `undo` (~24 tokens)

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

Input parameters:

- `file`

### `redo` (~22 tokens)

Redo the last undone edit (live editor).

Input parameters:

- `file`

### `get_editor_state` (~39 tokens)

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

### `set_editor_view` (~63 tokens)

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.

Input parameters:

- `scroll_x`
- `scroll_y`
- `zoom`

### `set_symmetry` (~85 tokens)

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.

Input parameters:

- `mode` (string, required)
- `x_axis`
- `y_axis`

### `ask_point` (~63 tokens)

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.

Input parameters:

- `title` (string)

### `get_asked_point` (~49 tokens)

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

### `cancel_ask_point` (~32 tokens)

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

### `show_choice_dialog` (~79 tokens)

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.

Input parameters:

- `message` (string, required)
- `options` (array, required)
- `title` (string)

### `get_dialog_choice` (~36 tokens)

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

### `watch_changes` (~59 tokens)

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.

### `get_watched_changes` (~39 tokens)

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

Input parameters:

- `reset` (boolean)

### `stop_watching_changes` (~19 tokens)

Detach the ``watch_changes`` listener.

### `run_lua` (~185 tokens)

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. Set ``edit=true`` when the code only edits the active
sprite: it then runs as one undo step, under the pixel cap and dry run. Without
\``edit`` the rails don't apply, and in a dry run this tool refuses to run.

Input parameters:

- `code` (string, required)
- `edit` (boolean)
- `file`
- `save` (boolean)

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/umarmuhammad18-aseprite-claude-connector/aseprite-claude-connector#diagnostics

## Score history

- 2026-11-21: 79
- 2026-11-20: 64
- 2026-11-19: 79
- 2026-11-18: 64
- 2026-11-17: 64
- 2026-11-16: 79
- 2026-11-15: 79
- 2026-11-14: 79
- 2026-11-13: 79
- 2026-11-12: 64

## Common questions

### What is the Aseprite Claude Connector MCP server?

Aseprite Claude Connector is an MCP server listed in the public MCP registry as io.github.UmarMuhammad18/aseprite-claude-connector. Let Claude draw in a running Aseprite, and export straight to Godot or Unity. This page covers its PyPI package (aseprite-claude-connector).

### Is the Aseprite Claude Connector MCP server safe to use?

Aseprite Claude Connector scores 79 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Aseprite Claude Connector MCP server expose?

Aseprite Claude Connector exposes 187 tools: status, get_sprite_info, describe_sprite, get_pixel, set_sprite_metadata, and 182 more. Their descriptions and schemas cost roughly 18,843 tokens of context every time the server is loaded.

### Is the Aseprite Claude Connector MCP server still maintained?

Aseprite Claude Connector is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Aseprite Claude Connector MCP server under?

Aseprite Claude Connector declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the Aseprite Claude Connector MCP server?

VerifyMCP ran 15 checks on Aseprite Claude Connector, covering Malware scan, Known CVEs, Install scripts, Dependency health and 11 more. One item could not be completed, a gap on our side rather than a finding about Aseprite Claude Connector: Stability. One category scores 0 for that reason, because we only credit what we can confirm. Endpoint Security and Transport & Reachability do not apply to a PyPI package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- PyPI project: https://pypi.org/project/aseprite-claude-connector/
- Socket report: https://socket.dev/pypi/package/aseprite-claude-connector
- Repository: https://github.com/UmarMuhammad18/aseprite-claude-connector
- Changelog RSS feed: https://verifymcp.io/servers/umarmuhammad18-aseprite-claude-connector/aseprite-claude-connector.xml
- Changelog JSON feed: https://verifymcp.io/servers/umarmuhammad18-aseprite-claude-connector/aseprite-claude-connector/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/umarmuhammad18-aseprite-claude-connector/aseprite-claude-connector.json
- HTML version of this page: https://verifymcp.io/servers/umarmuhammad18-aseprite-claude-connector/aseprite-claude-connector
