PixelLab MCP Server (Official)

@pixellab-code

リポジトリホームページドキュメント

基本情報

トランスポート

streamable-http

認証方式

APIキー

カテゴリ

メディアとデザイン

作者

pixellab-code

PixelLab MCP Server (Official) について

PixelLab MCP は、Claude Code、Cursor、VS Code などの AI コーディングアシスタントがゲームですぐ使えるピクセルアートを生成できるようにします：4 方向・8 方向のキャラクター、アニメーション、Wang タイルセットと横スクロール用タイルセット、アイソメトリックタイル、マップオブジェクト、自由形式のスプライト。https://api.pixellab.ai/mcp のリモート HTTP サーバーで、PixelLab の API トークンで認証し、生成には PixelLab アカウントの残高が使われます。

#pixel-art #game-development#sprites#tilesets#animation #image-generation #gamedev #official

接続情報

https://api.pixellab.ai/mcp

セットアップ

claude mcp add pixellab --transport http https://api.pixellab.ai/mcp --header "Authorization: Bearer ${PIXELLAB_API_TOKEN}"

PixelLab MCP Server のツール

103

Create one Pro Flash pixel-art image with an optional left-box style image. Custom sizes (Beta) accept width and height from 16 to 256 in multiples of 4 pixels. Query get_pro_flash_capabilities for native presets and provisional cost. The style image accepts {url}, {base64}, or {source_image_id}; prefer URLs for uploaded images. Style art must fit the native canvas without resizing. For several assets of one game, pass the same anchor sprite as style_image on every call (e.g. the hero's south rotation URL from get_character); without it each call picks its own look. style_options selects color_palette, outline, detail and shading independently. Default style uses existing PixelLab art. For a console or palette look (1-bit, Game Boy, PICO-8, any palette from Lospec) pass `palette` as its hex colours plus `palette_name`: the image is drawn for the palette and every pixel of the result is one of its colours; the style image keeps lending its look. Returns one image; the provisional generation charge varies with the canvas. Failed pixel grids use image-to- pixel-art with fixer on the generated box. Poll get_image(job_id); use source_image_id after completion.

Edit one Pro Flash image at its unchanged native canvas size. Supply image_url (preferred), image_base64, or an owned source_image_id. method=text requires description; method=reference requires reference_image ({url}, {base64}, or {source_image_id}). References must fit the source canvas. No-background defaults to the source's transparency. Optional palette correction matches source colors. Query get_pro_flash_capabilities for exact shapes. Returns one queued image; poll get_image(job_id), then download.

Regenerate one region of an image, keeping everything else pixel-identical. This is the repair tool: fix a malformed hand, erase a stray pixel cluster, swap just the cape, add an item to a specific spot. The area outside the mask is frozen, so the rest of the sprite cannot drift. Give the area as a rectangle (easiest — you only need coordinates): inpaint_image(image_base64=<png>, description="a clean open hand", mask_x=18, mask_y=30, mask_width=14, mask_height=14) or supply your own mask (white = regenerate, black = keep): inpaint_image(image_base64=<png>, description="...", mask_image_base64=<png>) Related: edit_image rewrites the WHOLE image from an instruction (no mask); create_map_object generates a new object matching a background's style and returns a transparent cutout, not your edited image. Image must be 32x32-512x512; above 256px on a side needs a Tier 2 plan. Cost: 10 generations for any canvas up to 256x256 (so 64x64 and 88x88 are both 10), 15 up to 341x341, 25 above. The whole image sets the price, not the mask. Generation time: ~30-90 seconds (async). Poll with get_image(job_id).

Replace white-mask pixels with Pro Flash, preserving unmasked RGBA bytes exactly. Source: image_url, image_base64, or owned source_image_id. Mask: a rectangle (all four mask_x/y/width/height), OR a same-size mask PNG via base64/URL. Mask RGB must be pure white=generate or black=keep; mask alpha is ignored. Empty masks are rejected. crop_to_mask is always true. Changes-only output is transparent outside the mask; Modify current layer returns a composite. Optional context_image requires bounding_box locating the source and is at most three times its native dimensions. No images or masks are rescaled. Query get_pro_flash_capabilities for shapes; poll the job with get_image.

Create a Pro Flash character from text, including its first image and eight V3 views. Supply description, optional width/height (default 64x64), and style_image. For a cast that matches (enemies drawn like the hero), pass the same anchor sprite as style_image on every call (e.g. the hero's south rotation URL from get_character); without it each call picks its own look. Animals: set template_id (bear, cat, dog, horse, lion) and keep 64x64 or larger (at 48x48 a cat came out small). Say "standing on all four legs" if it will walk: a cat and a dog came out sitting without it. Custom sizes (Beta) accept width and height from 16 to 256 in multiples of 4 pixels. First-direction generation is built in; no separate preview tool is needed. Alternatively reuse source_image_id or first_frame_url/base64 and omit size and style settings. A chosen image is preserved with transparent V3 padding, and only rotations are charged. Never provide both image sources. Poll get_character(character_id) or the returned outer background job until completed, including skeleton preparation, before downloading or animating.

Create a Pro Flash object from text, with one direction or eight V3 views. Supply description, optional width/height (default 64x64), and style_image. For props that match a game's characters, pass the same anchor sprite as style_image on every call (e.g. the hero's south rotation URL from get_character); without it each call picks its own look. Custom sizes (Beta) accept width and height from 16 to 256 in multiples of 4 pixels. First-direction generation is built into this call. n_directions=1 charges for one new image; n_directions=8 also charges for rotations. Alternatively reuse source_image_id or first_frame_url/base64 and omit size/style settings: saving one direction is then free, and eight views charge only rotations. Objects remain objects without skeletons. Poll get_object(object_id), then download its PNG (one direction) or ZIP (eight). No preview is regenerated.

Get Pro Flash exact native size pairs, controls and one-image output counts. Free identity-only lookup. Supply operation, width and height together for a provisional quote split into image/rotations/total. Finishing a selected preview bills only rotations; one-direction object finalization costs zero. Larger research sizes are not supported generation sizes. Read this before selecting dimensions for image, character or object creation, edit or inpaint.

Let a game project use a character, object, tileset or map you already own, or file an asset (gallery images too) into a game or folder on the website. A game gets the asset in its asset library; one not yet in any folder is also filed under that game. A folder only groups assets on the website: the asset moves into it and keeps every game it is in. Characters and objects move with all their states. A project's game can only load art that belongs to that project, and until now the only way to put art there was to create it from inside Game Builder. Art made anywhere else — this MCP server, the website — was invisible to every game, so the only route was to generate it a second time and pay for it again. A saved VFX effect id (My effects, vfx_workbench export) is not linked: the reply gives its files (game pack with manifest: frame order, timing, anchor) as download links and the command that puts them in the game. The kind is worked out from the id; you do not have to say which it is. Calling twice is harmless.

Stop a game project from using a character, object, tileset or map. This unlinks the art from the project. It does NOT delete the art: the asset stays in your library and can be added back at any time, and any other project using it is untouched. Use delete_character / delete_object / delete_topdown_tileset / delete_map to actually destroy something. Until now add_to_project had no inverse, so a project could accumulate art it no longer used — and a map that fails to export blocks every deploy of that project, with no way back out. The kind is worked out from the id; you do not have to say which it is. Calling twice is harmless.

Queue character creation. Returns immediately with character ID. Use get_character to check status. Which mode: v3 (default) for heroes, enemies and NPCs: clearly more detailed sprites than standard, 2 generations up to 88 px. For a quadruped from text, create_character_pro_flash(template_id=...) at 64 px. Pro when a new character must match an existing one (style_character_id) or to follow concept art. Standard for the lowest cost. Standard mode: 1 generation, 4 or 8 directions, ~2-5 min. Style params are soft guidance (the model tries to follow them but results may vary). Pro mode: 10-25 generations, always 8 directions, higher quality. Ignores all style/proportions params. Accepts style_character_id to match an existing 8-direction character's style, and concept_image_url to design the character from concept art, a painting or a photo. Pro mode only: pass `palette` (hex colours, plus `palette_name`) for a console or palette look (1-bit, Game Boy, PICO-8, any Lospec palette): all 8 directions are drawn for it and every pixel is one of its colours. v3 mode: 2-9 generations, 8 directions, highest quality. Outline and detail are soft guidance; shading/proportions ignored. v3 + reference_image_base64 / reference_image_url: rotates YOUR south-facing sprite into 8 (or 4) directions — use this (not create_8_direction_object) to turn an existing character sprite into a full character. Works for humanoids and quadrupeds (pass body_type="quadruped" + template). Add direction_images for directions you already drew; v3 fills only the rest. v3 without a reference image draws the sprite itself and is humanoid only. Humanoid: bipedal characters with proportion customization. Quadruped: 4-legged animals — requires template param (bear, cat, dog, horse, lion).

Queue a state (variant) of an existing character. The new character keeps the source's identity, body type, and proportions, with the edit applied consistently across all 4 or 8 rotations. Auto-waits up to 30s for the source to complete. A character is a group of states: `name` is the character's name (shared by all states), and each state has its own `state_name` — defaulting to the edit description truncated to 20 characters (a new character's first state is named "Idle"). Pass `state_name` to name the new state explicitly. IMPORTANT — this ALWAYS preserves the SAME individual's face and identity, even for edits like "elderly", "wounded", or a different class/role. It makes a variant OF this character (different outfit/pose/state), NOT a new character. To make a DIFFERENT character in the same art style, use create_character with matching size/view/outline/shading/detail params (and a v3 reference image if you want to match the look) — not create_character_state. Returns a new character_id grouped with the source via group_id. Inspect sibling states with `get_character` on either id. `palette` (hex colours, plus `palette_name`) puts every direction of the state on those colours, the source's rotations first; it can't be combined with use_color_palette_from_reference (max_colors alone can). Cost: 10-25 generations — the tier is resolved from the canvas at generation time, so the exact charge is not known when the call is made. The balance check runs against the 10 floor, which means a call CAN charge more than it reserved. Leave 25 generations of headroom, or check get_balance first, if you are near the end of a plan. Generation time: ~1-5 minutes (async). Poll with get_character(character_id).

Queue animation for a character. Returns immediately with job IDs. ~2-4 min. Modes (auto-detected, override with `mode`): - template: provide template_animation_id. 1 gen/direction; canvases over ~100px run in batches billed 1 each (256px: 4-9/direction, 30+ min) — the receipt gives the ceiling. Frame count fixed by template. - v3 (default when no template): custom from action_description. Cost is ceil(w·h·frames/65536) per direction on the GENERATED canvas, not the sprite — the silhouette grows it, so a 96px character commonly animates at ~132px and bills 3 rather than 2, and the frames are STORED at that canvas (a 128px character's come back ~176-180px; there is no keep-native-size option). At 8 frames before growth: 64px=1/dir, 96px and 128px=2, 160px=4, 256px=8. Directions are summed, not multiplied: each sizes its own canvas. frame_count 4-16. - pixminimax (beta): custom from action_description on PixMiniMax. frame_count multiples of 4 up to 40 at any size. Priced by canvas and frame count (64x64 at 4/8/16/40 frames = 1/1/2/6 gen/direction); the response's cost line is what was charged. ~1-7 min/direction. - skeleton-v3 (beta): the template_animation_id clip posed onto the character, steadier identity. 2-4 gen/direction. Animates all character directions by default (v3/pixminimax default to south only). Use get_character to see available template animations. Custom keyframes (mode='v3' or 'pixminimax', single direction): pass custom_start_frame_base64 to override the starting pose, and/or end_frame_base64 to interpolate toward a target pose. Quality escalation (try next if result is poor — delete_animation first, then retry): 1. template (1 gen/dir) — standard walk/run/idle 2. v3 (2/dir at 96px before the silhouette grows the canvas, ~4/dir at 160px) — custom action_description, cheap re-roll for small sprites 3. pixminimax (1-6/dir) — custom action_description, longer clips, cheap at large sizes Cost: template mode bills 1 generation per direction up to a ~92px canvas. Above that the clip splits into batches billed 1 each, so the charge follows the CLIP's frame count as well as the canvas: at 128px breathing-idle (4 frames) bills 1 per direction and walking (6 frames) bills 2; at 180px, 2 and 3; at 256px it is one generation per frame — 4 and 6 — and a direction takes 30+ min. The longest clips set the worst case: jumping-1 (9 frames) bills 3 at 128px, 5 at 180px, 9 at 256px. Frame counts are fixed by the clip and run 1 to 17 (static is 1, lead-jab 3, breathing-idle 4, walk/walking/cross-punch 6, any `-N-frames` clip is N); get_character lists your character's clips, and the submit receipt gives the exact ceiling before anything runs. v3: ceil(w*h*frames/65536) per direction on the GENERATED canvas. pixminimax: 64x64 at 4/8/16/40 frames = 1/1/2/6 per direction. skeleton-v3: 2-4 per direction.

Get character details, rotation URLs, animations, and download link. Branches by status: processing (progress+ETA), failed (error+retry), completed (full data).

List your characters with status. Returns compact one-line-per-character format. Use get_character(character_id) for full details on any character.

Delete ONE state of a character (the given id) with its rotations, animations and files. Other states in the same group are untouched; the group itself is removed only when its last state is deleted. To delete a whole multi-state character, call this once per state id (list them with get_character). Immediate — cannot be undone (in-flight jobs are wasted).

Replace ALL tags on a character (set operation, free, synchronous). Tags organize and filter characters in list_characters. Passing an empty list clears every tag. This replaces the full set: include existing tags you want to keep.

Delete animations from a character or object. Removes storage files and database rows. Use get_character()/get_object() first to see available animations. Omit direction to delete all directions at once. For objects, animation_group_id (from get_object) can be passed instead of animation_type.

Create an isometric tile. Returns immediately with tile ID. Use get_isometric_tile to check status and retrieve the result (~1-3 min).

Get an isometric tile by ID. Returns tile image and metadata if completed, or progress if processing.

List your isometric tiles. One line per tile with status. Use get_isometric_tile(tile_id) for full details.

Delete an isometric tile by ID. Only the owner can delete their own tiles. This action is permanent and cannot be undone.

Generate a Wang tileset for top-down game maps with corner-based autotiling. This tool starts an asynchronous tileset generation that returns immediately with a tileset ID. Use get_topdown_tileset to check status and retrieve the completed tileset. Which mode: standard (default) is the website's standard tileset, cheap and fast. mode="pro" paints the richest tiles (textured ground, raised banks, more shape controls): use it when the look matters, standard when cost does. Cost: standard is 1 generation now that it runs on pixen. (The classic model it replaced billed per stage: 1-4, usually 3 or 4 — NOT 1, over 6,124 prod charges, mean 3.1.) mode="pro" costs 15 generations for tiles up to 32 px, 25 above. Failed jobs are not charged. Tile count depends on mode and transition depth: - standard mode: 0.0 through 0.5 → 16 tiles (4x4); >0.5 → 25 tiles (4x8) - pro mode: 0.0 / 0.25 → 16 tiles; 0.5 / 1.0 → 25 tiles (pro promotes 0.5 past the 0.4 threshold, so a pro request at 0.5 returns 25, not 16.) The 25-tile layout has 21 distinct corner combos — the 4 extra wall-continuation tiles share corners with a twin and are distinguished by pattern_4x4, not corners. Vertices define terrain, tiles render based on their 4 corner values. Pro border shape (mode="pro"): roundness (0 square, 1 round, 2 corners cut at 45 degrees), boundary_amplitude + boundary_seed (a meandering border instead of a straight one; tall walls get a gentler one), step_slope (a raised bank from a cliff at 0 to a gentle slope at 2; transition_size 0.25), connect_diagonals (the two diagonal tiles' upper corners joined into one area). A value the chosen set can't draw is refused with what to send instead. Use case: Building top-down game maps with seamless terrain transitions. Algorithm: For each grid cell, sample terrain at 4 vertices, select matching tile. ## Creating Connected Tilesets One tileset holds exactly two terrains. Three or more (e.g. grass, dirt and water) need a chain of tilesets sharing a terrain, or the terrains that never share a set have no tiles to meet. Use base tile IDs to connect them: 1. Create first tileset (e.g., ocean→beach) and wait for completion 2. Use get_topdown_tileset to retrieve the base tile IDs 3. Use the beach base tile ID as lower_base_tile_id for next tileset (beach→grass) Example workflow: - Tileset 1: ocean (lower) → beach (upper) → get beach base tile ID - Tileset 2: beach (lower, using base tile ID) → grass (upper) → get grass base tile ID - Tileset 3: grass (lower, using base tile ID) → stone (upper) This ensures visual consistency across terrain transitions. mode="pro" takes a palette (its hex colours, e.g. Game Boy or PICO-8, plus palette_name): the set is drawn for those colours and every pixel of every tile is one of them, except connected terrain, which stays as the other tileset made it. Generation time: standard ~30 seconds, pro a few minutes (async processing)

Get a topdown Wang tileset by ID. Returns status, download links, base tile IDs for chaining, and an example map image. Download: no auth, the UUID is the key. GET /mcp/tilesets/{id}/image for the sheet PNG (add ?inline=true to be served the bytes instead of a CDN redirect, which Python stdlib clients need), GET /mcp/tilesets/{id}/metadata for per-tile bounding_box (x/y/width/height, use as atlas regions), corners (NW/NE/SW/SE, each lower/upper/transition, use for Wang autotiling) and pattern_4x4. Both answer 423 + Retry-After while generating. Godot walkthrough: the MCP resource pixellab://docs/godot/wang-tilesets.

List your top-down Wang tilesets. One line per tileset with status. Use get_topdown_tileset(tileset_id) for full details.

Delete a topdown tileset by ID. Only the owner can delete their own tilesets.

Generate a sidescroller tileset for 2D platformer games with side-view perspective. This tool starts an asynchronous tileset generation that returns immediately with a tileset ID. Use get_sidescroller_tileset to check status and retrieve the completed tileset. Which mode: standard (default) is the website's standard sidescroller tileset (pixen, side view), cheap and fast. mode="pro" paints the richest platforms; use it when the look matters, standard when cost does. Cost: standard is 1 generation now that it runs on pixen. (The classic model it replaced billed 2 or 3 generations — NOT 1, over 1,186 prod charges, mean 2.6.) mode="pro" costs 15 generations for 16 or 32 px tiles. Failed jobs are not charged. Creates tilesets optimized for 2D platformer games: - Side-view perspective (not top-down) - Transparent background (no background terrain) - Platform/ground tiles with flat surfaces (no slopes) - Optional decorative transition layer on top of base terrain Use case: Building 2D platformer games with seamless terrain tiles. ## Creating Connected Tilesets Use base tile IDs to create multiple tilesets that seamlessly connect: 1. Create first tileset (e.g., stone platform, either mode) and wait for completion 2. Use get_sidescroller_tileset to retrieve the base tile ID 3. Pass that base tile ID with mode="pro" to create the next tileset Chaining needs mode="pro": standard draws the new top around every edge of a chained platform instead of only on top. The base tile is the platform body: chaining reuses it and draws a new top. Example workflow: - Tileset 1: stone brick platform, grass on top → get base tile ID - Tileset 2: stone brick platform, snow on top (stone base tile ID, mode="pro") - Tileset 3: stone brick platform, moss on top (same base tile ID, mode="pro") A different body (wood, metal) is a new tileset without base_tile_id. Generation time: standard ~30 seconds, pro a few minutes (async processing)

Get a sidescroller tileset by ID. Returns status, download links, and tile count. Sidescroller tilesets are for 2D platformer games with transparent backgrounds.

List your sidescroller (platformer) tilesets. One line per tileset with status. Use get_sidescroller_tileset(tileset_id) for full details.

Delete a sidescroller tileset by ID. Only the owner can delete their own sidescroller tilesets.

Create a pixel art object with transparent background. ~30-90s. Returns object ID immediately. Two modes: - Basic (no background_image): standalone object from description. Requires width/height. - Style matching (with background_image): matches your map's art style. Width/height auto-detected. Default inpainting: oval 60%. Options: oval, rectangle, or custom mask. Canvas: 32-400px. Basic max 400x400, inpainting max 192x192. Transparency: the background is transparent up to 40,000px area (200x200, e.g. 128x256, 192x192); larger basic-mode canvases get a flat single-colour one. background_image: {"type": "base64", "base64": "..."} (file paths not supported) inpainting: {"type": "oval", "fraction": 0.3} | {"type": "rectangle", "fraction": 0.5} | {"type": "mask", "mask_image": "base64..."} Use get_map_object to check status. The object is permanent and can be placed on a map with place_map_object.

Get map object status and data. Returns image if completed. The object is permanent — place it on a map with place_map_object. Retries saving finished pixels when B2 or database persistence failed.

Queue a 1-direction object (10-25 generations, ~30-90s). Returns object_id immediately. When size ≤170, produces multiple candidates (4/16/64) in 'review' status. Call get_object to view candidates as inline images, then: - select_object_frames(object_id, indices=[...]) to keep specific ones - dismiss_review(object_id) to discard all Single candidates are kept automatically. For a fixed palette (Game Boy, PICO-8, any palette from Lospec) pass `palette` as its hex colours: objects are drawn for them and every pixel is one of them.

Queue an 8-direction object rendered from 8 angles (10-25 generations, ~2-4 min). Returns object_id immediately. Use get_object to check status. For single-direction objects, use create_1_direction_object instead. For a console or palette look (1-bit, Game Boy, PICO-8, any Lospec palette) pass `palette` as its hex colours plus `palette_name`: all 8 directions are drawn for it and every pixel is one of its colours.

Get object details. Branches by status: - processing: progress + ETA - review: candidate frame URLs + inline previews - completed: rotation URLs, animations, download link - failed: error + retry hint

List your objects with status and progress. One line per object. Use get_object(object_id) for full details.

Add an animation to an existing object. Returns one queued job per direction submitted; each job takes ~30-60s. Cost warning: when generating on a subscription, mode='pro' costs 10-25 generations per direction (80-200 for a full 8-direction animation). Prefer mode='v3' (default) — it usually produces higher quality results and is cheaper. For 1-direction objects, this animates the "unknown" direction. For 8-direction objects, a single call animates all 8 directions of one animation by default. Pass `directions` to animate a subset, or `animation_group_id` (from get_object) to add directions to an animation you've already started. Interpolation mode (mode='v3' only): pass `end_frame_base64` to interpolate toward a target pose — the model animates between the start frame and the end frame. The start defaults to the object's idle frame for that direction, but you can override it with `custom_start_frame_base64`. When either frame is provided, exactly one direction must be specified. Palette (mode='pro' only): pass `palette` as hex colours plus `palette_name` for a console or palette look (1-bit, Game Boy, PICO-8, Lospec); every pixel of every direction is one of them.

Queue a state (variant) of an existing object. Auto-waits up to 30s for the source object to complete. Returns a new object ID grouped with the source via group_id. An object is a group of states: `name` is the object's name (shared by all states), and each state has its own `state_name` — defaulting to the edit description truncated to 20 characters (a new object's first state is named "base"). Pass `state_name` to name the new state explicitly. A state is the SAME object in another condition (open/closed, lit, broken). A different item belongs in its own object — for a matching look, pass the source's image as style_images to create_1_direction_object. States move together: adding or removing one in a project or folder moves every state. `palette` (hex colours, plus `palette_name`) puts the state, every direction of it, on those colours; the source goes on them before the edit.

Permanently delete an object, its rotations/frames, animations, tags, project assignments, and storage files. Immediate — this cannot be undone.

Replace ALL tags on an object (set operation, free, synchronous). Tags organize and filter objects — see list_objects(tags=...). Passing an empty list clears every tag. This replaces the full set: include existing tags you want to keep.

Promote selected frames of a review object to individual completed objects. See get_object on a review-status object to view candidates inline. Each selected index becomes its own 1-direction object. Once no frames remain in the review object it is deleted automatically. If a call times out it may still finish: check get_object before retrying (promoted frames leave the review object, and re-selecting one is refused).

Discard a review-status object and delete all its candidate frames. Used when none of the consistent-style candidates are worth keeping.

Queue a pixel-art UI panel (10-25 generations, ~30-90s). Returns ui_asset_id immediately. Omit `pieces` for a default rounded-rect panel. Use get_ui_asset to check status. For a fixed palette (Game Boy, PICO-8, any palette from Lospec) pass `palette` as its hex colours: the panel is drawn for them and every pixel is one of them.

Get UI panel details. Processing → progress; completed → image URL + download.

List your UI panels with status. One line per asset. Use get_ui_asset(ui_asset_id) for full details.

Permanently delete a UI panel (and, for a template, its split elements + their states) plus the backing image files. Immediate — this cannot be undone.

Ask for help using PixelLab MCP tools, workflows, or features. A knowledge agent searches our docs and returns a concise answer.

Report something broken, confusing or missing — a PixelLab tool, the sandbox (build, deploy, git, playtest), the game template code, or the website. Specific beats polite. Read daily by the team.

Create pixel art tiles (pro). Generates multiple tile variations by drawing tile shape outlines and having AI fill them with pixel art. Supports hexagonal, isometric, and square top-down tile types. This tool starts asynchronous generation that returns immediately with a tile ID. Use get_tiles_pro to check status and retrieve completed tiles. **Two modes:** 1. **Shape mode** (default): Specify tile_type, tile_size, tile_view to control tile shape. 2. **Style mode**: Provide style_images to match existing tiles' style and dimensions. **Prompting tip:** Number each tile for best control: "1). grass tile 2). dirt tile 3). stone tile 4). water tile" The number of tiles is auto-computed based on tile size. Examples: - "1). grass tile 2). dirt tile 3). stone tile 4). water tile 5). sand tile 6). lava tile" - "1). ocean water 2). shallow water 3). wet sand 4). dry sand" For a console or palette look (1-bit, Game Boy, PICO-8, any palette from Lospec) pass `palette` as its hex colours plus `palette_name`: the tiles are drawn for them and every pixel of every tile is one of them (with style_images the style tiles' colours are then not copied). Generation time: ~15-30 seconds (async processing)

Create a connectable PATH/ROAD tile set (18 configs). Generates straights, corners, T-junctions, a crossroads, dead-ends and a plain ground tile, all sharing one look. The set ships per-tile edge rules (N/E/S/W bitmasks), so a map editor or your own autotiler can pick the right piece from a cell's painted neighbours — see get_tiles_pro for the rules. For terrain transitions (grass meeting water) use create_tiles_pro(tile_feature="tileset"); for walls and floors use create_building_kit. For a console or palette look (1-bit, Game Boy, PICO-8, any palette from Lospec) pass `palette` as its hex colours plus `palette_name`: the set is drawn for them and every pixel of every tile is one of them. Non-blocking: returns a tile id immediately; poll with get_tiles_pro.

Create a BUILDING KIT — floor, connectable walls, doorways, pillar, stairs. Generates a matched vocabulary of architectural pieces (walls 1-3 tiles high) you assemble into structures. Wall segments carry outline rules so a cell's walls follow the shape of the floor area you place them around. Roofs: the kit has two. The upper-floor tile (floor_roof, floor2's material) is FLAT — lay it on top of the walls for a flat roof, terrace or upper storey. The roof pieces (materials layout only) slope up from every eave (`roof_profile`) and flatten inside. A description such as "flat roof" changes the material only, never this shape. Not a terrain set: for grass-meets-water use create_tiles_pro(tile_feature="tileset"); for roads use create_path_tiles. For a console or palette look (1-bit, Game Boy, PICO-8, any palette from Lospec) pass `palette` as its hex colours plus `palette_name`: the kit is drawn for them and every pixel of every piece is one of them. Non-blocking: returns a tile id immediately; poll with get_tiles_pro.

Get tiles pro by ID. Returns tile data and storage URLs if completed, or progress if processing.

List your tiles (pro). One line per tile with status. Use get_tiles_pro(tile_id) for full details.

Delete tiles pro by ID. Only the owner can delete their own tiles. This action is permanent and cannot be undone.

Convert between a portrait and a character sprite (pro). Preserves the subject's identity/outfit while matching an internal size-specific pixel-art style for the chosen view. For a fixed palette (Game Boy, PICO-8, any palette from Lospec) pass `palette` as its hex colours: the sprite is drawn for them and every pixel is one of them. This tool starts asynchronous generation that returns immediately with a job ID. Use get_portrait_character to check status and retrieve the sprite. Examples: - Turn a character portrait into a top-down RPG sprite: create_portrait_character(image_url=<portrait_png_url>, direction="portrait_to_character", view="low top-down", result_size=64) - Turn a full-body sprite into a bust portrait: create_portrait_character(image_url=<character_png_url>, direction="character_to_portrait", view="low top-down", result_size=64) Generation time: ~30-80 seconds (async processing)

Get a portrait ↔ character result by job id. Returns the sprite (inline + download URL) if completed, or progress/error.

Attach a bust portrait to a character (no generation, free). A portrait is the starting frame for talking animations — set one, then create_vocal_animation generates the mouth positions from it. Overwrites any existing portrait. Examples: - Straight from a portrait job: set_character_portrait("<character-uuid>", from_job_id="<portrait-job-uuid>") - From your own artwork: set_character_portrait("<character-uuid>", image=<png_base64>)

Generate a talking mouth-position set ("visemes") for a character's portrait. Produces one keyframe per mouth shape, all sharing the chosen expression, so the character can be lip-synced to any line of text afterwards. Building the set costs generations ONCE; turning it into talking animations with create_talking_gif is free. Works two ways. With `character_id` the set is saved onto that character, so every later call needs only the id — use this when the character exists. With `image` you generate straight from a portrait and nothing is stored; the frames live in the job for 8 hours and you reference it by job id. Requires a paid plan (tier 1+). The character form needs a portrait set first. Examples: - Default talking set for a character: create_vocal_animation(character_id="<uuid>") - Add an angry expression to the same character: create_vocal_animation(character_id="<uuid>", mood="angry") - Just a portrait, no character: create_vocal_animation(image=<portrait_png>) Generation time: ~2-5 minutes (async processing)

Check a vocal-animation job and see which mouth positions have landed. Mouth positions stream in as they are picked, so a running job already reports partial progress. On completion the set is saved onto the character and ready for create_talking_gif.

Turn text into a talking GIF using a character's existing mouth positions. FREE — no generations are spent. This only sequences frames that create_vocal_animation already produced, so the expensive step happens once per expression and every line of dialogue after that costs nothing. Examples: - create_talking_gif(character_id="<uuid>", text_to_speak="Welcome, traveller!") - create_talking_gif(character_id="<uuid>", text_to_speak="You dare return?!", mood="angry") - portrait-only, no character: create_talking_gif(from_job_id="<vocal job id>", text_to_speak="Hello!") Returns immediately (no job to poll).

Get the lip-sync frame plan for a line of dialogue — for animating in a game. FREE, and nothing is rendered. Use this instead of create_talking_gif when the game should animate the mouth itself: you get the spritesheet URL, the row for the expression, and a frame list giving the column to draw and how long to hold it. create_talking_gif is the better answer when you just want a playable file. Timings are exact here — unlike a GIF, an engine can hold a frame for any duration. Example: - get_lip_sync("<uuid>", "Welcome to the village, traveller!") Returns immediately (no job to poll).

Create a pixel-art font (pro). Produces a glyph atlas + a ready-to-use TrueType (.ttf) font with uppercase, lowercase, digits 0-9, and common game-UI punctuation. Costs 15 generations or at least $0.115 in credits. This tool starts asynchronous generation that returns immediately with a job ID. Use get_font to check status and retrieve the atlas + font. Example: create_font(description="warm orange arcade font", weight="Bold", glyph_px=16) Generation time: ~30-80 seconds (async processing)

Get a font result by job id. Returns the glyph atlas (inline) + download URLs for the atlas PNG and the .ttf if completed, or progress/error otherwise.

Generate a freeform pixel-art image from text (no character/object rig). Use this for anything that is just an image: item icons, backgrounds, card art, props, concept frames. For a rotatable character use create_character; for an asset-pack prop use create_1_direction_object; for a map prop that matches an existing map's style use create_map_object. Canvas is 16-400px per side, total area 32x32 to 400x400. Examples: - create_image_pixflux(description="health potion bottle", width=64, height=64, no_background=True) - create_image_pixflux(description="forest background", width=320, height=180) - img2img over your own sprite: create_image_pixflux(description="same knight but in gold armor", init_image_base64=<png>, init_image_strength=150) init_image_strength is how much of the input is KEPT (inverted vs most img2img APIs): 500 barely moves it, 300 is subtle, ~150 is a visible edit, ~50 keeps only the rough composition. For editing an image use edit_image; for fixing one region use inpaint_image. Cost: 1 generation. Generation time: ~10-40 seconds (async). Poll with get_image(job_id).

Generate a freeform pixel-art image with the Pixen model. Pixen is the newer of the two fast generators and holds up better on small sprites. Pick between the three text-to-image tools like this: - create_image_pixflux — when you need an init image (img2img), a palette given as an image, isometric, or shading control. - create_image_pixen — this one; cleaner small sprites, bigger canvas. - create_image_pro — best quality, returns a set of candidates, costs more; takes a palette as hex colours (1-bit, Game Boy, PICO-8, NES, Lospec). Canvas: 16-768 per side and each side must be a multiple of 4; total area 16x16 to 512x512. Below 32 the canvas must be SQUARE, so the small sizes are 16x16, 20x20, 24x24 and 28x28. Cost: 1 generation. Generation time: ~10-40 seconds (async). Poll with get_image(job_id).

Generate pixel art with the Pro model — best quality, several candidates. This is "Create Image (Pro)". It returns a SET of options in one call rather than a single image, by the larger side: 64 candidates up to 32px, 49 at 33-35px, 36 at 36-41px, 25 at 42-50px, 16 at 51-64px, 9 at 65-84px, 16 at 85px, 4 at 86-170px, 1 above that. Cost is per call, not per candidate, so a small canvas is where it pays off. Unlike the other two text-to-image tools it accepts labelled references: create_image_pro( description="knight in the same armour", reference_images='[{"base64": "<hero png>", "usage": "character base"}, {"base64": "<armour png>", "usage": "outfit"}]') No facing control: nothing here sets which way the subject looks, and a reference does not either. To turn a picture you already have into 8 facings, use create_object_pro_flash(first_frame_base64=..., n_directions=8). For a console or palette look (1-bit, Game Boy, PICO-8, NES, any palette from Lospec) pass `palette` as its hex colours, e.g. ["#081820", "#346856", "#88c070", "#e0f8d0"], plus `palette_name`: the image is drawn for the palette and comes back using only those colours. A palette name alone is not enough - the colours are what the result is put on. `max_colors` caps the colours in each image (e.g. 6 for an NES-style sprite). Pick between the three: create_image_pixflux for img2img or isometric; create_image_pixen for clean small sprites at 1 generation; this one when quality matters more than cost, or for a palette given as hex colours. Cost: 10-25 generations for the CALL, never multiplied by the candidate count. The rule is one step: the sheet is your canvas times the candidates per side, and you pay that sheet's tier. Square canvases work out to 10 for 16-32, 43-64, 86-128 and 171-256; 15 for 33-42, 65-85, 129-170 and 257-341; 25 above. Candidates per call, square canvases by side: 64 for 16-33, 49 for 34-35, 36 for 36-41, 25 for 42-51, 16 for 52-65, 9 for 66-85, 4 for 86-171, 1 from 172. A NON-SQUARE canvas is not the longest side applied to those ladders, and it is not the area either: both sides are read, and a narrower canvas can fit one more per side and so land a tier cheaper. 48x72 returns 16 candidates at 10 generations while 72x72 returns 9 at 15, on the same longest side. Verified non-square costs: 320x180 and 72x56 are 10, 384x216 and 416x176 are 15, 512x288 and 688x384 are 25. For a size not listed, don't extrapolate from the square ladders — the submit receipt reports the actual cost and candidate count before anything renders. Generation time: ~1-10 minutes (async). Poll with get_image(job_id).

Get a raw-image result by job id, or a gallery image by `gallery:<id>`. Returns the image(s) inline plus no-auth download URLs when completed, or progress/error otherwise. A completed job also reports its gallery save: the Creator ``asset_id`` once saved, or a failure note (the image is still delivered) while the save is being retried.

List the images in your Creator gallery (pixellab.ai/create), newest first, one line each: its `gallery:<id>` reference, description, size and frame count. Pass the reference to get_image to download an image, to pixelart_workbench to look at or edit it, and to save_to_asset to save a fix over it.

Edit an existing image with a text instruction or a reference image (pro). This returns YOUR image, edited — the pose, composition and pixel style are preserved and only what you asked for changes. Use it to recolour armour, add an accessory, change an expression, or restyle frames to match a reference. Two modes, picked by what you pass: - text edit: edit_image(images_base64=[<png>], description="give him a red cape") - reference edit: edit_image(images_base64=[<png>], reference_image_base64=<png>) Putting a reference outfit on an animation (2+ frames, motion kept)? Use transfer_outfit — it is built for that. Reference mode here is for one image. Related tools: create_image_pixflux(init_image_base64=...) regenerates the whole image instead of editing it; create_map_object generates a NEW object matching a map's style and returns a cutout, not your edited image. Frame limit depends on output size: <=64px 16 frames, <=80px 9, <=128px 4, larger 1 (one fewer in reference mode). Inputs max 512x512. Cost: 10-25 generations (billed by the whole frame grid, so a single 64x64 edit costs the same as sixteen of them — batch your frames). Generation time: ~30-90 seconds (async). Poll with get_image(job_id).

Edit an image with a text instruction on the Pixen model (fast, 1 generation). Returns YOUR image edited — pose, composition and pixel style are preserved and only what you asked for changes. Pick between the two edit tools: - edit_image_pixen — this one; 1 generation, ~10-40s, ONE frame, input max 256px per side and output max 256x256 in AREA. The default for a single sprite. - edit_image — pro quality, 10-25 generations, ~30-90s, edits up to 16 frames consistently in one call, accepts a reference image and inputs up to 512px. Worth it for animation frames, a character's directions, or when pixen's result isn't good enough. Sizes: the input is capped PER SIDE at 256 (crop an oversized source — never rescale pixel art); the output is capped by AREA at 256x256 = 65,536px, so 128x512 is fine but 320x320 is not. Output defaults to the input's size. BOTH sides of both must be multiples of 4 — a 63x222 sprite is rejected; pad it with transparent pixels to 64x224 first (padding keeps the pixel grid, rescaling destroys it). Need a bigger canvas? edit_image takes inputs up to 512. Cost: 1 generation. Generation time: ~10-40 seconds (async). Poll with get_image(job_id).

Make the normal map of a sprite or an animation, so a game engine can light it (Pro 0.5 generation, Lite 0.1 generation). The map is a PNG the sprite's size: RGB = which way each pixel faces (red right, green up in the opengl convention, blue toward the viewer), alpha 255 wherever the sprite shows and 0 elsewhere. Each part of the sprite gets its own shape — a head is round, a hat a cone, a wall faces south — so a light moving around it shades it the way a 3D model would. An animation (`character:<id>:<direction>:<animation>`, a GIF, a strip) comes back as a strip, one map per frame side by side in frame order, made from one plan so the light stays steady as it moves. Use it in Phaser with the Light2D pipeline: this.load.image('knight', ['knight.png', 'knight_n.png']) sprite.setPipeline('Light2D'); this.lights.enable().setAmbientColor(0x555555) Godot: assign it as the sprite's normal map (CanvasTexture). Unreal: convention "directx". Each slider left out starts where the kind of picture puts it (an isometric box gets flat faces), which suits most pictures. Lower surface_detail for clean flat-shaded art, raise part_shapes for a rounder body; strength makes the whole map stronger or flatter. Cracks, holes and gaps between plates come out as grooves even when they glow. mode="lite" (the default, recommended) reads the map from the art alone in about a second and is almost always as good; mode="pro" plans every part (a head, an arm in front of the body, a crack sunk in). Sizes: each frame 8 to 512 px per side, up to 32 frames. Any colours (painted art works); pixel art gives the cleanest parts. Cost: Pro 0.5 generation, Lite 0.1 generation. Time: Pro ~15-60 s, Lite a few seconds (async). Poll with get_image(job_id).

Reskin an existing animation with the outfit from a reference image (pro). Every frame keeps its pose and motion; only the appearance changes to match the reference — new armour on a walk cycle, a new colour scheme across an attack, a weapon carried through the whole sequence. transfer_outfit(frame_urls=[<f1>, <f2>, ...], reference_image_url=<outfit>) The reference should be the SAME character in the new outfit. It does not reliably turn one character into another. Needs 2+ frames. For ONE image use edit_image(reference_image_base64=...) instead; for a stored character's animation pass its frame URLs from get_character. Frame limit depends on output size (the reference takes one grid slot): both sides 32-64px up to 15 frames, both 65-80px up to 8, larger side 81-256px up to 3. Frames over the limit: split across calls with the same reference and seed. For a console or palette look (1-bit, Game Boy, PICO-8, any palette from Lospec) pass `palette` as its hex colours plus `palette_name`: every pixel of every frame is one of them (the palette, not the reference, sets the colours). Needs a tier 1 subscription or higher. Cost: 10-25 generations, billed by the whole grid — 2 frames cost the same as 15 at 64x64, so batch them. Generation time: ~1-2 minutes (async). Poll with get_image(job_id); frames come back in input order.

Convert an image, render or photo into pixel art. This is the general-purpose converter: give it any picture and get pixel art back at the size you ask for. Use it when a user brings their own artwork, a screenshot, or an AI render and wants it as a sprite. Two dials decide how much licence the model takes: - default (faithful=False, init_image_strength=0) — reinterprets the subject as pixel art. Cleanest sprites, least like the original. - faithful=True with init_image_strength around 100-300 — reproduces the source. Use it when the user says "keep it exactly like this". Higher is NOT more faithful in a useful way: past ~300 the model stops transforming and returns the source image, which is not pixel art. Related tools: create_portrait_character converts a picture into a character portrait specifically; unzoom_image is what you want if the input is ALREADY pixel art that has merely been upscaled — running it through here would redraw art that only needed downscaling. Input max area 2048x2048, output max 512x512. Cost: 1 generation. Generation time: ~20-60 seconds (async). Poll with get_image(job_id).

Convert an image, render or photo into pixel art with Pro Flash. Redraws the picture as clean pixel art and picks the output size itself (detected pixel scale), so there is no size parameter. Use image_to_pixelart instead when the result must be an exact width and height. Optional description steers the style (dithering, mood). For a console or palette look (1-bit, Game Boy, PICO-8, any palette from Lospec) pass `palette` as its hex colours plus `palette_name`: the picture is drawn for them and every pixel of the result is one of them. Supply image_url (preferred), image_base64, or an owned source_image_id. Sources over 2048px on the longest side are scaled down first. Transparent areas become a white background. Cost: 6 generations. ~30-60 seconds. Returns one queued image; poll get_image(job_id), then download.

Downscale upscaled pixel art back onto its true pixel grid. Pixel art found online is almost always scaled up — a 32x32 sprite saved at 512x512, where every art pixel is a 16x16 block. Every tool that takes a reference or style image works far better on the real 32x32 sprite, and this recovers it: the pixel grid is detected and the image is downsampled onto it. Run this FIRST whenever a user supplies pixel art from outside PixelLab and you are about to pass it to create_image_pixflux(init_image), a style image, edit_image, or create_character. If the art was never upscaled it is already at native size and this is unnecessary. Do not confuse it with image_to_pixelart: that CONVERTS a non-pixel-art picture, redrawing it. This one only downscales art that is already pixel art. Input must be at least 256x256 (grid detection needs the pixels) and at most 2048x2048 in area. The result is OPAQUE: grid detection works in RGB, so transparency in the input is composited onto white first. If the user needs a cut-out sprite back, tell them so rather than handing back a white-boxed result. Cost: 0.1 generations. Runs locally in under a second — poll once with get_image(job_id).

Clean up pixel art — sharpen edges, drop stray pixels, tighten the palette. Keeps the sprite on its existing pixel grid and at its existing size. Use it on art that has been through a lossy pipeline, on hand-drawn art that needs tidying, or on output from another tool that is nearly-but-not-quite on-grid. Passing several frames in one call corrects them together, which is what you want for an animation or a character's directions. This does NOT resize. If each art pixel is a block of screen pixels the image is upscaled, not damaged — run unzoom_image first, then correct if it still needs it. Transparency survives: the alpha channel is carried around the model and re-applied, so a cutout sprite does not come back on a white box. Max area 1024x1024 per frame. Cost: 0.1 generations. Generation time: ~20-60 seconds (async). Poll with get_image(job_id).

Quantize images onto a smaller, shared palette. Pixel art reads as pixel art partly because of its restricted palette. AI output and converted artwork often carry hundreds of near-identical colors; this snaps them onto a tight palette, optionally with ordered dithering. Passing several frames in one call is the point: they are quantized TOGETHER, so an animation or a character's eight directions come back sharing ONE palette instead of drifting apart frame by frame. Quantizing them one at a time is the mistake this tool exists to prevent. Three ways to choose the palette: - omit num_colors and the palette image — the size is auto-detected - num_colors — quantize to exactly this many colors - palette_image — reuse the colors of an existing image (the game's palette) The result carries a `palette` strip you can feed back as palette_image_base64 to lock later frames onto the same colors. Total size limit across all frames is 512x512 worth of pixels (sixteen 64x64 frames, or four 128x128). Cost: 0.1 generations. Runs locally in about a second — poll once with get_image(job_id).

Animate any image from a text description of the motion. Works on a loose sprite — unlike animate_character / animate_object, which need an id of something PixelLab generated. get_image returns frame_count + 1 images: index 0 is your input frame unchanged, then the generated ones. Play them in order. Examples: - animate_image(first_frame_base64=<png>, action="walking forward", frame_count=8) - pin the ending: animate_image(first_frame_base64=<open>, last_frame_base64=<closed>, action="chest lid closing", frame_count=6) Limits: frame max 256x256, and width x height x frame_count <= 524288 — so a 256x256 frame allows 8 frames, a 64x64 frame allows all 16. Cost scales with total pixels (a 64x64 8-frame animation is 1 generation, a 128x128 16-frame one is 4). Generation time: ~30-180 seconds (async). Poll with get_image(job_id).

Animate with text (PixMiniMax): animate any image from a motion description. Works on a loose sprite — unlike animate_character / animate_object, which need an id of something PixelLab generated. Same inputs as animate_image; frame counts are multiples of four, capped by the frame's longer side (see Limits). get_image returns frame_count + 1 images: index 0 is your input frame unchanged, then the generated ones. Play them in order. Examples: - animate_image_pixminimax(first_frame_url=<png>, description="walking forward", frame_count=8) - pin the ending: animate_image_pixminimax(first_frame_base64=<open>, last_frame_base64=<closed>, description="chest lid closing", frame_count=4) - short prompt, expanded for you: animate_image_pixminimax(first_frame_url=<png>, description="shooting a bow", direction="south", enhance_prompt=True) Caption fields (subject_description, initial_pose, view, direction) left out are read off the image by an AI model, which can decline some requests; the job then fails asking you to send them yourself. Beta, every plan. Limits: frame max 256x256; 4 to 40 frames in multiples of 4 at any size. Cost: priced by generation time, which follows the UPSCALED canvas the model works on — x4 up to 64px, x2 up to 128px, x1 above (longer side). So 64, 128 and 256 all price identically, and each is the MOST expensive size in its neighbourhood. At 64/128/256: 4-8 frames = 1 generation, 12-16 = 2, 20-24 = 3, 28 = 4, 32-36 = 5, 40 = 6. Four pixels over the step is ~3x cheaper on a long clip: 40 frames costs 6 at 128x128 and 2 at 132x132 (likewise 64x64 -> 68x68). Splitting helps too — four 8-frame calls cost 4 where one 32-frame call costs 5. Generation time: ~1-6 minutes (async). Poll with get_image(job_id). Powered by MiniMax H3.

Animate with skeleton v3 (beta): animate a sprite along a skeleton you pose, one per frame. Every frame is drawn from the one reference image, so the character keeps its identity while the pose is exactly what you send. Use this when you hold a rig or can derive skeletons; for a stored PixelLab character, animate_character with a template animation is far less work. Nothing returns a template clip's keypoints to an API caller, so there is no library of walk cycles to fetch: derive them from your sprite with `POST /v2/estimate-skeleton`, bring your own rig (COCO-18 maps straight across, see `keypoints`), or use animate_character(mode="skeleton-v3"), which poses a template clip onto a stored character and needs no keypoints at all. get_image returns exactly len(keypoints) images — the reference frame is not echoed back. Play them in order. Limits: sprite max {MAX_DIMENSION}x{MAX_DIMENSION}; {MIN_FRAMES} to {MAX_FRAMES} frames, each skeleton holding all 18 humanoid joints. Cost: priced by generation time, which barely moves with length, so every legal frame count falls in one of three steps — 3 frames = 2 generations, 4 to 14 = 3, 15 = 4. Generation time: ~3-6 minutes (async). Poll with get_image(job_id).

Run one pixel-art command on a drawing or image you already made. This is the engine's own command line: it checks work, explains it and improves it. Commands: check and explain (read-only): - lint <id> [--rules outline_gap,orphan_pixel,…] — pixel-art defects, each naming the node and command that drew them - inspect <id> --region x0,y0,x1,y1 --scale 10 — a zoomed crop with its exact colours - measure <id> --at x,y — what is at a pixel and who drew it - explain <id> — resolved geometry, per-command footprints, before rendering - motion / storyboard / silhouette / reveal / clusters / parts <id> — reports - score <id> — a 0-100 pixel-art discipline score with a breakdown - compare <id> <id> — two results side by side Improve (returns a NEW drawing id): - shade <id> --band 2 --light=-1,-1 — banded shading along a colour ramp - selout <id> — selective outlining; reoutline / clean-lines / aa / mirror - cluster <id> --at x,y --action recolor --color <name> — one guarded cluster - repair <id> — deterministic cleanup of drift, strays, fringe and noise Sheets and frames (returns a NEW image id): - split <image> --grid 3x3 — a sprite sheet, strip or grid as an animation, one frame per cell (columns x rows) - join <image> <image> … [--as sheet|rows|animation] [--columns n] — pictures or animations as one sprite sheet, one per row, or one animation - scale <image> --by 4 — the same picture or animation bigger, each pixel a 4x4 block (a sticker, a print); nothing is redrawn Craft operations need colour ramps: run `extract-palette <id>` first, then pass `--ramps skin=dark,mid,light`. Anything unclear: `describe cli`, `describe lint_rules`, `describe ramps`. Free for subscribers.

Make an animated pixel-art effect (spell, hit, explosion, aura, projectile, weather...) yourself, around the user's sprite or on its own: drop in tuned parts, write layers, look at every render, then export. Export saves it to the user's My effects on pixellab.ai (re-editable there with sliders) and returns a GIF and a spritesheet PNG + JSON; --game-pack adds a ZIP of every piece for a game engine (--part <id> just one). Free for subscribers. Commands: - start [--sprite <image>] [--projectile <image>] [--preset <name>] -> step id - <step id> <tool> '<JSON>' -> add_part, set_part, remove_part, throw, render, get_preset, get_part, list_parts; a change returns a new step id - <step id> export [--name N] [--replace <effect id>] [--game-pack | --part <id>] - describe start | parts | recipe | craft | cookbook | edits | presets | tools Sprites and exports are pixelart_workbench ids, so the two work together. Start with describe start.

Save pixel art into one of your characters, objects, Creator gallery images or tilesets, replacing a rotation, one direction of an animation, a gallery image or a tileset's tiles — or add it to the gallery as a new image (free, no generation). Use it to keep a fix made with pixelart_workbench or another image tool: the character and object creators, the Creator gallery, the map editor, downloads and game projects then show the new pixels. The image must match what it replaces — the same canvas size and the same number of frames; a different size can go to the gallery as a new image. Save each direction with its own call. The replaced frames are kept: the reply gives the save_to_asset call that puts them back. Examples: - save_to_asset(image="<workbench id>", target="character:<id>:south") - save_to_asset(image="<workbench id>", target="character:<id>:east:<group id>") - save_to_asset(image="<workbench id>", target="object:<id>") - save_to_asset(image="<workbench id>", target="gallery:<id>") - save_to_asset(image="<workbench id>", target="gallery:new", description="knight holding a sword, idle") - save_to_asset(image="<edited sheet>", target="tileset:<id>")

Create an empty map seeded with a tileset and everything connected to it, or with a tile group. The map starts with no painted cells — paint it with edit_map, which grows the bounds as you go. Tile size comes from the seed tileset. A map started from a tile group is a tile map instead: its tiles go on tile layers with place_map_tiles, which can stack them. Being in the same family makes a terrain AVAILABLE, not blendable: only a pair with its own tileset renders a border. Check with view_map, which names every unpaired pair and the create_topdown_tileset call that joins it.

Delete one of your maps. Immediate — there is no undo. A map wired into a project is loaded by that project's game by id, so deleting one that a game still references breaks that game's next build. The response says how many projects referenced it.

List your maps, most recently edited first. Pass `search` to find one by name — accounts reach four figures of maps, so paging is not a way to look something up. Maps are made in PixelLab's Map Workshop; use get_map to see one and edit_map to paint terrain on it.

Show a map as an ASCII grid, one character per terrain cell. With no crop you get the whole map downsampled to fit; pass x/y/width/height for a 1:1 view of one area. Coordinates are terrain cells and can be negative — the rulers show the real numbers, so read them off the view and pass them straight to edit_map. Maps built from tile groups (isometric, hex, oblique and similar tiles) show their tile layers: for every cell the tile on top and the stack level it sits on, plus each stacked column spelled out. Change those with place_map_tiles.

Paint terrain on a map: rivers and roads with `path`, areas with `rect`. You choose regions, not tiles — the tileset picks the actual tile art for every corner, and shoreline rows between terrains are inserted for you. Name a terrain the map doesn't have yet and the tileset providing it is attached automatically, along with any tileset connected to it. Returns what changed, an ASCII view of the affected area, and — when the edit used new art or went wrong — a rendered image of it. Pass show=true to see the image any time; use view_map to look at somewhere you did not just paint.

Render the map to an image and return it, terrain and objects together. Use this to judge how a map LOOKS — get_map's ASCII shows you where terrain is, never what it looks like. Crop with x/y/width/height (the same cell coordinates get_map and edit_map use) to inspect an area closely. This renders from the terrain grid, so it always shows the map's CURRENT state, including edits a human has not opened Map Workshop to see.

Place objects or characters on a map, at a terrain cell or an exact pixel. Objects are how a map gets trees, houses, rocks and NPCs — terrain painting (edit_map) only covers ground. A tileset tiles a SURFACE, so anything with a silhouette has to be an object. Position: x/y stands the sprite on that cell (the coordinates get_map shows). world_x/world_y puts it at an exact world pixel instead, as Map Workshop's free drag does — use it to match positions from a game scene or an isometric layout that does not fall on the cell grid. For many objects pass `placements`: one call, one save. Returns a picture of the result by default, because a placement that is one cell off, or far bigger than you expected, is invisible in text.

Place, stack and erase tiles on a map's tile layers — the map editor's tile painting, with its Stack layer control. A map made from tile groups (isometric, hex, oblique, square tiles) keeps each group as a tile layer; get_map lists them and shows, per cell, the tile on top and its stack level. A cell holds a column of tiles: level 0 is the ground, and each level above sits one tile height higher, so a `stack` of 3 builds a pillar and "on_top" builds on whatever is there. Placing on a cell's level replaces the tile already there. As in the editor, a tile placed on one ground layer clears that same cell and level on any other ground layer drawn on the same grid. Tiles go down exactly as given: for connected sets, pick the tile drawn for that spot's neighbours (get_tiles_pro lists each tile's mask). A building kit is several layers: floor, interior walls, outer walls, roof (when the kit has roof pieces) and pieces (pillars, doorways, stairs). Lay floor tiles and the outer walls follow the floor's outline. Interior walls and roofs take no tile: each cell's piece follows its neighbours. A doorway is cut into the wall at that cell, and stairs lay both halves. get_map lists what each kit layer takes. Returns what changed and a view of the area: the top tile and the top level of every cell, and each stacked column level by level.

List the objects and characters placed on a map, with their cell positions. Gives you the placement id that move_map_object and remove_map_object take. A placement id is per-PLACEMENT, not per-asset — the same tree placed twice has two ids.

Move a placed object or character to a different cell or an exact pixel, or change its layer. Keeps its sprite and refs. world_x/world_y positions it to the pixel, as Map Workshop's free drag does; `layer` alone re-orders it without moving it.

Remove placed objects or characters from a map. Deletes placements only — the object or character itself is untouched and can be placed again. Pass `placement_id` for one, or `asset_id` to clear every placement of one asset at once.

List your game projects with IDs, branches, and git clone URLs.

List the deployed AI agents you own (the 'deploy your own agent' projects). Returns each agent's slug — pass it as `agent` to agent_inspect / agent_talk.

Debug a deployed agent's LIVE runtime: its state, recent chat, LLM/tool traces (errors first, with the model's real input/output), and grown memory (journal/agenda/lessons/feedback). Use this to see what the agent ACTUALLY did before changing its source. `focus='traces'` zooms in on bad turns.

Send a message to a deployed agent (as its owner) and get its reply — to test how it responds while you're working on it. Goes through the agent's normal chat loop (so it may run its tools).

Check your account balance: remaining credits (USD) and subscription generations.

Get a URL to upload a local image file to, without needing your API token. Use it whenever you have an image on disk and a tool wants an image: send the file with one curl, and pass the `upload:<id>` it returns to any parameter that takes an image URL (image_urls, reference_image_url, init_image_url, a style_image "url" ...). This avoids pasting base64 into a tool call, which clients truncate and can corrupt. Free. The URL works for 15 minutes and for any number of files. Uploads are kept 3 days. An animated GIF keeps all its frames.

Search the Phaser/game dev knowledge base for tips, patterns, and code examples. Returns semantically matched tips from the curated knowledge base — useful for Phaser 4 patterns, TypeScript game dev, Vite build issues, map systems, collision, camera follow, and other game builder topics.

Cancel a pending or processing background job. Releases the concurrency slot immediately so you can start new work. Already-completed or already-failed jobs are left unchanged.

List your active background jobs (pending + processing). Use this to find stuck jobs you can cancel with cancel_job.

Wait for your running generations instead of sleeping and polling. Returns as soon as min_finished (default 1) of your pending/processing jobs finish, immediately when none are running, or at the timeout. Free. Then call the matching get_* tool for the result; call wait_for_jobs again for the jobs still running.

概要

PixelLab MCP Server (Official) とは？

PixelLab MCP は PixelLab 公式のホスト型 MCP サーバーで、AI コーディングアシスタントが Claude Code、Cursor、VS Code などのクライアントから、ゲームですぐ使えるピクセルアート（4 方向・8 方向のキャラクター、アニメーション、タイルセット、マップオブジェクト、スプライト）を直接生成できるようにします。

PixelLab はこのワークフローを「Vibe Coding」と呼んでいます。エージェントがアセットを生成し、それを使うゲームコードをすぐに書きます。Godot、Unity、GameMaker Studio、Raylib、Pygame など、どのエンジンやフレームワークでも使えます。サーバーは https://api.pixellab.ai/mcp のリモート HTTP エンドポイントで、PixelLab の API トークンで認証します。生成には PixelLab アカウントの残高が使われます。

PixelLab MCP Server (Official) の使い方

pixellab.ai でサインアップし、MCP セットアップページでサインインして API トークンを取得します。
トークンを Authorization: Bearer ヘッダーに入れて、AI アシスタントにサーバーを追加します。
エージェントにアセットを依頼します。

リモート HTTP サーバーに対応した任意の MCP クライアント向けの手動設定：

{
  "mcpServers": {
    "pixellab": {
      "url": "https://api.pixellab.ai/mcp",
      "transport": "http",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

YOUR_API_TOKEN を自分のトークンに置き換え、バージョン管理には含めないでください。

Claude Code

claude mcp add pixellab https://api.pixellab.ai/mcp -t http -H "Authorization: Bearer YOUR_API_TOKEN"

Claude Code を起動すると、pixellab サーバーの下に PixelLab のツールが表示されます。

Cursor、VS Code、その他のクライアント

インタラクティブなセットアップページには、Cursor、VS Code（v1.102 以降で MCP をネイティブサポート）、Codex CLI、Windsurf、Gemini CLI、Zed、Cline、Claude Desktop、Continue、Kiro、Junie、Warp、LM Studio などのコピー&ペースト用手順があり、stdio のみ対応のクライアント向けの方法も用意されています。それ以外の場合は上記の手動設定を使ってください。

ヒント： PixelLab はプロンプトに https://api.pixellab.ai/mcp/docs を含めることを推奨しています。全ツールを LLM 向けに解説したガイドで、エージェントが適切なツールを選びやすくなります。

PixelLab MCP Server (Official) の主な機能

方向付きキャラクター：人型または四足（bear、cat、dog、horse、lion）のキャラクターを 4 方向または 8 方向で生成。
アニメーション：walk、run、idle、攻撃などのテンプレートアニメーション、またはテキストで説明したカスタムモーション。
タイルセット：つなげて連続した地形を作れるトップダウンの Wang タイルセット、横スクロール用プラットフォームタイルセット、アイソメトリックタイル。
マップオブジェクトとマップ：既存マップのスタイルに合わせられる透過背景の小物と、マップを作成・ペイントするツール。
画像ツール：テキストからのピクセルアート生成、編集、インペイント、画像からピクセルアートへの変換、減色、クリーンアップ。
ノンブロッキングなジョブ：生成系ツールはすぐにジョブ ID を返してバックグラウンドで処理するため、エージェントは多数のアセットをまとめてキューに入れられます。
共有ライブラリ：MCP で作ったキャラクターとタイルセットは、同じアカウントの PixelLab Web 版 Character Creator と Map Workshop に表示されます。

PixelLab MCP Server (Official) のツール

ツールの数は多く、頻繁に増えています。主なグループ：

キャラクターとアニメーション：create_character、animate_character、get_character、list_characters、および create_character_state による状態バリエーション。
タイル：create_topdown_tileset、create_sidescroller_tileset、create_isometric_tile、pro 版タイルツールの create_tiles_pro、create_path_tiles、create_building_kit。
オブジェクトとマップ：create_map_object、create_8_direction_object、animate_object、create_map、edit_map、view_map。
画像：create_image_pixflux、create_image_pixen、create_image_pro、edit_image、inpaint_image、animate_image、image_to_pixelart、reduce_colors。
その他：UI パネル（create_ui_asset）、ピクセルフォント（create_font）、エフェクト（create_vfx）、しゃべるポートレート（create_vocal_animation）。
ジョブとアカウント：list_jobs、wait_for_jobs、cancel_job、get_balance。

PixelLab は自社のゲーム制作エージェント向けの chat ツールと sandbox ツールも公開しており、ゲームを *.dev.pixellab.run にデプロイできます。

PixelLab MCP Server (Official) のユースケース

ゲームの高速プロトタイピング：「8 方向の騎士キャラクターを作って、歩行と待機のアニメーションをキューに入れ、Godot のシーンに組み込んで。」
地形づくり：「海から砂浜へのトップダウンタイルセットを作り、続けて砂浜から草地へつないで。」
「石レンガに苔のトランジション」のような横スクロール用タイルセットでプラットフォーマーのステージを作成。
マップに小物を配置：「マップのスタイルに合ったオークの木のマップオブジェクトを作って。」
コンセプトアートの変換：レンダー画像や写真をピクセルアートにして、パレットを整えます。
ゲームジャム：エージェントが 1 つのセッションでスプライトとそれを読み込むコードの両方を作ります。

PixelLab MCP Server (Official) と代替ツールの比較

PixelLab API v2：同じ機能を REST で提供し、ドキュメントは https://api.pixellab.ai/v2/llms.txt にあります。バッチ処理やゲーム内でのリアルタイム生成には API、エージェントに作業を任せるなら MCP が向いています。
コミュニティ製ラッパー：rabbitcannon/pixellab-forge-mcp などの GitHub プロジェクトが PixelLab API をラップしています。上記のホスト型サーバーは PixelLab 自身が運営しており、ローカルインストールは不要です。
エンジン側のサーバー：PixelLab がアセットを作り、Godot MCP Server、Unity MCP Server、Blender MCP Server などのエンジン側 MCP サーバーがエディター内での作業を担います。組み合わせて使うと効果的です。

PixelLab MCP Server (Official) のトラブルシューティング

エージェントが PixelLab のツールがないと言う：MCP が設定されていないか、クライアントが再読み込みされていません。URL、Authorization: Bearer ヘッダー、トークンを確認し、クライアントを再起動します。MCP の URL に curl で直接アクセスする方法には切り替えないでください。
結果がまだ出ない：生成は非同期で、キャラクターは通常 2〜5 分ほどかかります。対応する get_* ツールでポーリングするか wait_for_jobs を呼び出し、timeout_seconds はクライアント側のツールタイムアウトより短く設定します。
大きな画像が失敗する・壊れる：MCP クライアントは大きなインライン base64 をよく切り詰めます。代わりに URL パラメーター（例：reference_image_url や image_url）か get_upload_url を使ってください。
想定外のコスト：pro と v3 モードは standard モードより多くの generations を消費します。pro アニメーションには明示的な confirm_cost が必要で、get_balance で残りの credits とサブスクリプションの generations を確認できます。

よくある質問

PixelLab MCP は公式ですか？

はい。PixelLab が `https://api.pixellab.ai/mcp` で運営し、pixellab.ai でドキュメントを公開しています。GitHub の `pixellab-code/pixellab-mcp` リポジトリには README のみがあり、サーバーのソースコードは含まれていません。

PixelLab MCP は無料ですか？

PixelLab にはクレジットカード不要の無料トライアルがあります。その後の生成はアカウントの credits またはサブスクリプションの generations を消費し、コストはツールとモードによって異なります。

どの API キーが必要ですか？

PixelLab の API トークンです。セットアップページでサインインすると取得できます。`Authorization: Bearer YOUR_API_TOKEN` として送信します。

Claude Code、Cursor、VS Code で使えますか？

はい。PixelLab は Claude Code、Cursor、VS Code を主要クライアントとして挙げており、Codex CLI、Gemini CLI、Windsurf、Zed、Cline、Claude Desktop にも対応しています。

ローカルとリモートのどちらですか？

リモートです。サーバーは PixelLab が HTTP でホストしているため、MCP クライアントの設定以外にインストールするものはありません。

どのゲームエンジンに対応していますか？

どのエンジンでも使えます。出力は画像アセットで、PixelLab は Unity、Unreal Engine、Godot、GameMaker Studio、Raylib、MonoGame、Defold、Love2D、Pygame を挙げています。

生成されたダウンロードリンクは非公開ですか？

ダウンロード URL は UUID がキーになっており認証が不要なため、リンクを知っていれば誰でもダウンロードできます。共有には注意してください。

生成にはどれくらい時間がかかりますか？

ほとんどのツールはすぐにジョブ ID を返します。キャラクターは通常 2〜5 分ほど、シンプルな画像は 1 分以内で完了します。

PixelLab MCP - Vibe Coding AI Toolkit のリモート MCP サーバーとは何ですか?

PixelLab MCP - Vibe Coding AI Toolkit のリモート MCP サーバーは、https://api.pixellab.ai/mcp にホストされた Model Context Protocol エンドポイントです。AI アシスタントはローカルに何もインストール・実行することなく接続できます。

PixelLab MCP - Vibe Coding AI Toolkit の MCP サーバーにはどう接続しますか?

エンドポイント https://api.pixellab.ai/mcp を Claude Code、Cursor、VS Code など任意の MCP 対応クライアントに追加してください。このページのセットアップ手順で各クライアントを一度に設定できます。

PixelLab MCP - Vibe Coding AI Toolkit の MCP サーバーは認証が必要ですか?

はい。PixelLab MCP - Vibe Coding AI Toolkit は API キーが必要です——取得方法は公式ドキュメントを確認し、クライアントの設定に追加してください。

PixelLab MCP - Vibe Coding AI Toolkit の MCP サーバーはどのトランスポートを使用しますか?

PixelLab MCP - Vibe Coding AI Toolkit は streamable-http エンドポイントを公開しており、これはリモート MCP サーバーで広く使われ、主要な MCP クライアントがサポートするトランスポートです。

他のリモート MCP サーバー

AIS Gateway

CVE prioritization using exploitation signals, plus agent heartbeat monitoring and state capsules. Some tools use API-key or x402 access.

AdaptlyPost

AdaptlyPost: Schedule and publish social posts to Instagram, TikTok, YouTube, X, Facebook, LinkedIn, Pinterest, Threads, and Bluesky from any MCP client.

API Direct

Search and read public data from X/Twitter, Reddit, YouTube, Instagram, TikTok, Facebook, Threads, Bluesky, Trustpilot, Amazon, Google Maps, news, forums and the web. 90+ read-only tools plus ready-made research playbook

AI-Ready Webpage Extractor (Apify)

Convert web pages to clean Markdown and retrieval-ready chunks with browser rendering support.

AOI — Environmental Intelligence

AOI is a commercial environmental-intelligence gateway that gives AI agents programmatic access to 38 real-world intelligence capabilities — climate risk, satellite monitoring, methane detection, water & soil, vegetation

PixelLab MCP Server (Official) について

接続情報

セットアップ

PixelLab MCP Server のツール

create_image_pro_flash

edit_image_pro_flash

inpaint_image

inpaint_image_pro_flash

create_character_pro_flash

create_object_pro_flash

get_pro_flash_capabilities

add_to_project

remove_from_project

create_character

create_character_state

animate_character

get_character

list_characters

delete_character

update_character_tags

delete_animation

create_isometric_tile

get_isometric_tile

list_isometric_tiles

delete_isometric_tile

create_topdown_tileset

get_topdown_tileset

list_topdown_tilesets

delete_topdown_tileset

create_sidescroller_tileset

get_sidescroller_tileset

list_sidescroller_tilesets

delete_sidescroller_tileset

create_map_object

get_map_object

create_1_direction_object

create_8_direction_object

get_object

list_objects

animate_object

create_object_state

delete_object

update_object_tags

select_object_frames

dismiss_review

create_ui_asset

get_ui_asset

list_ui_assets

delete_ui_asset

search_help

agent_feedback

create_tiles_pro

create_path_tiles

create_building_kit

get_tiles_pro

list_tiles_pro

delete_tiles_pro

create_portrait_character

get_portrait_character

set_character_portrait

create_vocal_animation

get_vocal_animation

create_talking_gif

get_lip_sync

create_font

get_font

create_image_pixflux

create_image_pixen

create_image_pro

get_image

list_images

edit_image

edit_image_pixen

create_normal_map

transfer_outfit

image_to_pixelart

image_to_pixelart_pro_flash

unzoom_image

correct_pixelart

reduce_colors