ai.ludo/game-assets

Tools

• adjustSpritesheet

  Adjust Sprite Sheet: re-export a previously generated sprite animation with different sheet settings - frame count, frame size, loop trimming or whitespace cropping - without generating the animation again. Free (no credits). Pass the `spritesheet_url` you received from `animateSprite`, `animateSpriteKeyframes`, `transferMotion`, `editSpritesheet`, `rotateSpritesheet` or an earlier adjust - it must be a spritesheet you generated through the API within the last 7 days; arbitrary external images are not accepted. Omit a setting to keep the source's value. The animation itself is unchanged: this only re-cuts the same video into a new sheet, so use it to fix framing (for example an effect clipped by True Size: re-export with a fixed `frame_size` or 0), to change the frame count or size for your engine, or to turn loop trimming on or off. It cannot change the motion, margins or content - use editSpritesheet for that. The source is left as it is and the result is a new spritesheet with its own `spritesheet_url`. The job result is the same sprite result as animateSprite (`spritesheet_url`, `video_url`, grid fields, optional GIF and frame URLs, and the source's `audio_url` when it has one). Limited to 20 calls per 5 minutes and 200 a day. Pass an optional request_id to tag the result for later retrieval via listGenerations (type spritesheet). Async generation job: returns `{id, status}` - poll `getApiJob` (job and credit contract: see the server instructions).

  shallow
• animate3DModel

  Generate text-driven skeletal animations for an already-rigged 3D model. Pass the rigged GLB in `model` (URL or base64) and a motion `prompt` (e.g. "walking", "swinging its axe"). The model must already have a skeleton — rig it first via the rig endpoint if not. Synchronous: returns num_variants candidate animations (default 4), each a standalone animation-only GLB (skeleton + one clip, no mesh) in `glb_url` plus an mp4 `preview_url`, so you can pick the best one and fuse it with your model in a game engine or three.js. mode selects the representation — rot_trans (default, most faithful) or rot_only (for retargeting). Animation quality is hit-or-miss, which is why multiple candidates are returned. Credits are charged once per call regardless of variant count, only on success. Requires an API key (user scope). Credits: This endpoint consumes 0.2 credits per call.

  shallow
• animate3DModelPreset

  Apply a curated animation preset to an already-rigged 3D model (retargeting). Pass the rigged GLB in `model` (URL or base64) and a `preset_id` from the animation presets list (see the spritesheet animation-presets endpoint) — only presets that expose a `clip_url` can be applied to a 3D model. The model must have a humanoid-template rig (rig it with rig_type humanoid_template or humanoid_template_hands). Synchronous: returns one retargeted animation — a standalone animation-only GLB in `glb_url` plus an mp4 `preview_url` — in the same `animations` envelope as the animate endpoint. crop_loop trims the clip to its seamlessly-looping span (omit to follow the preset's own loop flag); in_place removes net travel so the character moves on the spot, as game-engine locomotion expects (omit to follow crop_loop). Credits are charged only on success. Requires an API key (user scope). Credits: This endpoint consumes 0.2 credits per call.

  shallow
• animateSprite

  Animate a static sprite into a spritesheet driven by a motion text prompt (image-to-spritesheet): supply an initial_image (URL or base64) plus a motion_prompt like "walking" or "attack slash", and optionally a final_image to interpolate between a start and end frame. For animations driven by up to three keyframes (including a middle frame), use animateSpriteKeyframes instead. Synchronous: the call blocks until the spritesheet is rendered and returns a single sprite result directly (spritesheet URL, frame layout, and optionally a GIF or individual frame URLs when requested) with no separate polling step. The chosen model must support sprite animation and the duration must be valid for it; incompatible model/duration combinations return HTTP 400. Credits are charged only on success, based on the produced duration and never more than the duration you requested. For best results, call generatePose first to put the character into the desired pose, then animate it here; use listAnimationPresets to discover named presets, and prefer transferMotion when you already have a reference video or preset to copy motion from rather than describing it in text. Pass an optional request_id to tag the result so you can locate it later via getSpriteResults. Requires an API key (user scope). Credits: cost varies by model and duration (credits/sec): Blitz 1.9/s (min 4), Eagle 2.6/s (min 4), Eagle with Audio 3.1/s (min 4), Forge 1.5/s (min 4); see this endpoint's full pricing table in the API docs.

  shallow
• animateSpriteKeyframes

  Animate a sprite through up to three fixed keyframes — initial_image, middle_image and final_image (each a URL or base64) — producing a spritesheet that interpolates through the provided frames in order. At least one of initial_image or middle_image is required (a final_image alone has nothing to anchor the animation); any keyframe may be omitted. The motion_prompt is optional here — when omitted, the motion is derived purely from the keyframes. Always runs on the Forge model (there is no model parameter; Forge is the only model supporting middle keyframes), so durations follow Forge's pricing. Synchronous: the call blocks until the spritesheet is rendered and returns a single sprite result directly (spritesheet URL, frame layout, and optionally a GIF or individual frame URLs when requested) with no separate polling step. Credits are charged only on success, based on the produced duration and never more than the duration you requested. Use animateSprite instead for the classic single-image + text-prompt animation with model choice. Pass an optional request_id to tag the result so you can locate it later via getSpriteResults. Requires an API key (user scope). Credits: cost varies by model and duration (credits/sec): Forge 1.5/s (min 4); see this endpoint's full pricing table in the API docs.

  shallow
• cancelApiJob

  Cancel a queued job you started through the API or MCP and refund its credits. Jobs that are already running cannot be canceled (409). Returns the canceled job. This is free (no credits). Requires an API key (user scope).

  shallow
• create3DModel

  Convert a single source image into a textured 3D model (image-to-3D). Synchronous: the call blocks while the mesh is generated, decompressed, and re-uploaded, then returns a downloadable GLB model_url plus an array of snapshot image URLs rendered from different angles (handy for previews). Accepts optional mesh controls: target_num_faces (max triangle count, 1000-200000, default 50000), texture_size (1024 or 2048, default 2048), and texture_type ("pbr", "simple", or "none", default "pbr"). Credits are charged only on success. Pass an optional request_id to tag the result so you can locate it later via get3DModelResults. Requires an API key (user scope). Credits: This endpoint consumes 3 credits per call.

  shallow
• create3DModelImage

  Make a character image ready to turn into a 3D model, the first step of Directional Sprites on the web. Pass a prompt describing the character, your own image (URL or base64), or both. With an image, it is redrawn as a 3D render, and the prompt becomes the changes to make (e.g. "add a red cape and a sword"); leave the prompt out to keep the character as it is. A redraw is a new picture each time, so call again for another try. The job result is a single image result with a url (not an array): pass that url as create3DModel's image. create3DModel itself converts the image it is given as it is. A call with neither prompt nor image is rejected with HTTP 400, and an image larger than 15MB too. Credits are held when the job is accepted and refunded if it fails or is cancelled. Pass an optional request_id to tag the result so you can retrieve it later via listGenerations (type image). Async generation job: returns `{id, status}` - poll `getApiJob` (job and credit contract: see the server instructions). Credits: This endpoint consumes 0.5 credits per result.

  shallow
• createAmbiance

  Produce a looping background ambiance soundscape from a text description, such as "windy forest at dusk" or "busy tavern interior". Synchronous: the call blocks until generation finishes and returns a single audio result containing a URL; there is no separate polling step. The description field is required and duration is capped at 10 seconds (0 means auto-pick based on the description). Credits are charged on success. Use this for continuous, atmospheric background loops; use createSoundEffect for short discrete sound effects, createMusic for musical pieces, and createAudioTransform to remix an existing audio sample. Pass an optional request_id to tag the result so you can locate it later via getAudioResults. Requires an API key (user scope). Credits: This endpoint consumes 2 credits per call.

  shallow
• createAudioTransform

  Remix an existing audio sample (a sound effect, ambiance, or music clip) into a variation guided by a text prompt, for example turning a track into an 80s synthwave or metal version. Both the sample and the prompt are required; the sample is uploaded as a URL or base64 audio and must be at most 15MB or the call returns HTTP 400, and duration must be one of the allowed values (0 means match the source, otherwise multiples of 10 up to 180 seconds). Synchronous: the call blocks until generation finishes and returns a single audio result containing a URL; there is no separate polling step. The optional modification_strength (0 to 1, default 0.5) controls how far the result departs from the original. Credits are charged on success. Use this to transform existing audio you already have; use createSoundEffect, createAmbiance, or createMusic to generate audio from scratch. Pass an optional request_id to tag the result so you can locate it later via getAudioResults. Requires an API key (user scope). Credits: This endpoint consumes 3 credits per call.

  shallow
• createDirectionalSprites

  Directional Sprites: render a 3D model into one spritesheet per direction, in a style. Pass the GLB in `model` (URL or base64; rigged, to animate it - see create3DModel with rig, or rigModel) and at most one animation: `animation_url` (the `glb_url` of an animation from animate3DModel or animate3DModelPreset, made for this model), `preset_id` (a preset from listAnimationPresets, retargeted onto the model; any rig type can take one, though retargeting does not succeed on every model, and when it does not the call returns an error) or `model_animation` (the name of an animation the GLB itself carries). With no animation each sheet is a single frame. `directions` are where the camera stands around a character facing S (up to 8); every direction is rendered together, on the same frame size, scale and floor, so the sheets line up. Pick the style with listDirectionalSpriteStyles (style_id, and style_params for its settings) and check it with previewDirectionalSprites first. The job result is one sheet per direction, in the order asked, each with its `spritesheet_url`, grid fields, fps and `render_3d`. Credits are held for every direction when the job is accepted and charged for the sheets that come back; a failed or cancelled job is refunded. Pass an optional request_id to tag the sheets for later retrieval via listGenerations (type spritesheet). Async generation job: returns `{id, status}` - poll `getApiJob` (job and credit contract: see the server instructions). Credits: This endpoint consumes 1 credit per direction (one sheet each).

  shallow
• createDirectionalStills

  Directional Sprites stills: render a 3D model as it is (no animation) into one large image per direction, in a style, on a transparent background. Pass the GLB in `model` (URL or base64), the `directions` (up to 8, rendered together so they line up) and the style (listDirectionalSpriteStyles). Each still is a sprite image you can animate with animateSprite or edit with editImage. The job result is one image per direction, in the order asked. Credits are held for every direction when the job is accepted and charged for the images that come back; a failed or cancelled job is refunded. Pass an optional request_id to tag the images for later retrieval via listGenerations (type image). Async generation job: returns `{id, status}` - poll `getApiJob` (job and credit contract: see the server instructions). Credits: This endpoint consumes 0.5 credits per direction (one image each).

  shallow
• createImage

  Generate game-art images from a text prompt alone, selecting an image_type (e.g. sprite) and optionally art_style, perspective, and aspect_ratio. Synchronous: the call blocks until generation finishes and returns an array of image results, each with a url; request n (1-8) to control how many variations come back. Because it generates purely from text it takes no source image, so there is no upload size limit to trip. Credits are charged only on success, scaled to the number of images produced. Use createImage to make new images from scratch; use generateWithStyle to match a reference image's art style, editImage to modify an existing image, and removeBackground to cut out a subject. Pass an optional request_id to tag the results so you can retrieve them later via getImageResults. Requires an API key (user scope). Credits: This endpoint consumes 0.5 credits per result.

  shallow
• createMusic

  Produce a piece of music from a text description, such as "epic orchestral battle theme" or "calm piano melody", with optional lyrics. Synchronous: the call blocks until generation finishes and returns a single audio result containing a URL; there is no separate polling step. The description field is required; duration must be one of the allowed values (0 means auto, otherwise multiples of 10 up to 180 seconds) and out-of-range values return HTTP 400. Credits are charged on success. Use this for songs and musical scores; use createSoundEffect for short sound effects, createAmbiance for looping background soundscapes, and createAudioTransform to remix an existing audio sample. Pass an optional request_id to tag the result so you can locate it later via getAudioResults. Requires an API key (user scope). Credits: This endpoint consumes 3 credits per call.

  shallow
• createSoundEffect

  Produce a short sound effect (SFX) from a text description, such as "laser gun firing" or "footsteps on gravel". Synchronous: the call blocks until generation finishes and returns a single audio result containing a URL; there is no separate polling step. The description field is required, duration is capped at 10 seconds (0 means auto-pick based on the description), and you may set loop to true for a seamlessly looping effect. Credits are charged on success. Use this for short, discrete sounds; use createAmbiance for a continuous looping background soundscape, createMusic for musical pieces, and createAudioTransform to remix an existing audio sample. Pass an optional request_id to tag the result so you can locate it later via getAudioResults. Requires an API key (user scope). Credits: This endpoint consumes 2 credits per call.

  shallow
• createSpeech

  Convert text to speech by cloning the voice from an audio sample you provide (voice-cloning text-to-speech). Both text and sample are required; the text is limited to 1000 characters and the sample is supplied as a URL or base64 audio that must be at most 15MB, with violations returning HTTP 400. Synchronous: the call blocks until generation finishes and returns a single audio result containing a URL; there is no separate polling step. Credits are charged on success. Use this when you have a reference voice sample to clone; use createSpeechPreset to speak with a built-in named preset voice instead, and createVoice to design a brand-new voice from a text description rather than cloning one. Pass an optional request_id to tag the result so you can locate it later via getAudioResults. Requires an API key (user scope). Credits: This endpoint consumes 1 credits per call.

  shallow
• createSpeechPreset

  Convert text to speech using a named built-in preset voice, with optional emotion and language settings. Both text and voice_preset_id are required and the text is limited to 1000 characters; invalid input returns HTTP 400. Synchronous: the call blocks until generation finishes and returns a single audio result containing a URL; there is no separate polling step. Credits are charged on success. Use this when you want a ready-made catalog voice and do not need to supply your own sample; use createSpeech to clone a voice from an audio sample instead, and createVoice to design a new voice from a text description. Pass an optional request_id to tag the result so you can locate it later via getAudioResults. Requires an API key (user scope). Credits: This endpoint consumes 1 credits per call.

  shallow
• createSpriteAudio

  Generate a sound effect for a previously generated spritesheet animation. Pass, as `spritesheet_video_url`, the `video_url` you received from `animateSprite`, `animateSpriteKeyframes`, `transferMotion`, or `editSpritesheet` - it must belong to a spritesheet you generated within the last 7 days; arbitrary external videos are not accepted. Spritesheets generated with the hydra model already come with `audio_b64`, so only call this for forge / forge-pixel output or to replace hydra's sound. Optionally add a `prompt` describing the sound you want. The job result is the URL of the generated audio file only; no video is returned. The audio is also attached to the spritesheet, so it appears as `audio_b64` in listGenerations (type spritesheet), where the spritesheet keeps the `request_id` it was generated with. Pass an optional `request_id` to make this call idempotent and to find its job again; it must not be one you already used for another generation. Async generation job: returns `{id, status}` - poll `getApiJob` (job and credit contract: see the server instructions). Credits: This endpoint consumes 3 credits per call.

  shallow
• createVideo

  Generate a short video clip from a source image and a motion text prompt (image-to-video). Synchronous: the call blocks until rendering finishes and returns the video URL and its actual duration in seconds — there is no separate polling step. Optionally pass `final_image` to interpolate between a start and end frame. The chosen `model` and `duration` must be compatible (incompatible combinations return HTTP 400); see the `model` and `duration` fields for the values each model accepts. Credits are charged only on success, based on the produced duration and never more than the duration you requested. Pass an optional `request_id` to tag the result so you can locate it later via `getVideoResults`. Related tools: use `createImage` for static images, `animateSprite` for sprite-sheet animation, and `getVideoResults` to list videos you generated earlier. Requires an API key (user scope). Credits: cost varies by model and duration (credits/sec): Blitz 1/s, Eagle 1.3/s, Eagle with Audio 1.8/s; see this endpoint's full pricing table in the API docs.

  shallow
• createVideoFromReferences

  Generate a video from 1-5 reference images and a text prompt (references-to-video). Unlike createVideo, which animates a single source image, this composes a new scene that borrows characters, objects, and style from the reference images. Each image can be a URL or base64. Synchronous: the call blocks until rendering finishes and returns the video URL and its actual duration in seconds. Choose the output shape with `aspect_ratio` ("default" lets the model decide). The chosen `model` and `duration` must be compatible (incompatible combinations return HTTP 400). Credits are charged only on success, based on the produced duration and never more than the duration you requested. Pass an optional `request_id` to tag the result so you can locate it later via `getVideoResults`. Related tools: `createVideo` for image-to-video, `editVideo` to modify a generated video. Requires an API key (user scope). Credits: cost varies by model and duration (credits/sec): Eagle 1.5/s, Eagle with Audio 2/s; see this endpoint's full pricing table in the API docs.

  shallow
• createVoice

  Design a new voice from a character description (such as "deep-voiced warrior" or "cheerful young girl") and have it speak a short line of text, returning a sample of that newly created voice. Both voice_description and text are required, the spoken text is limited to 200 characters or the call returns HTTP 400, and type selects "human" or "non-human" voices. Synchronous: the call blocks until generation finishes and returns a single audio result containing a URL; there is no separate polling step. Credits are charged on success. Use this to invent and audition a voice from a description; use createSpeech for text-to-speech that clones a specific voice from an audio sample, and createSpeechPreset for text-to-speech using a named preset voice. Pass an optional request_id to tag the result so you can locate it later via getAudioResults. Requires an API key (user scope). Credits: This endpoint consumes 1 credits per call.

  shallow
• editImage

  Modify an existing image according to text instructions: supply a source image (URL or base64) and a prompt describing the changes (e.g. "add clouds", "warmer color scheme"), with an optional reference_image for extra style or content guidance. Synchronous: the call blocks and returns an array of image results, each with a url; request n (1-4) to control the number of edited variations. Provided images are uploaded and validated, and any image larger than 15MB is rejected with HTTP 400. Credits are charged only on success, scaled to the number of images produced. Use editImage to transform a specific existing image; use createImage to generate from text alone, generateWithStyle to borrow a reference's art style, and removeBackground for the dedicated background-removal case. Pass an optional request_id to tag the results so you can retrieve them later via getImageResults. Requires an API key (user scope). Credits: This endpoint consumes 0.5 credits per result.

  shallow
• editSpritesheet

  Edit a previously generated spritesheet: re-prompt its underlying animation (edit_mode "prompt"), extend the frame beyond its borders ("outpaint"), or repair a bad loop ("fix_loop"). Pass the `spritesheet_url` you received from `animateSprite`, `transferMotion`, or an earlier edit — it must be a spritesheet you generated within the last 7 days; arbitrary external images are not accepted. A `prompt` is required for edit_mode "prompt", optional for "outpaint", and not accepted for "fix_loop"; optionally add up to 5 reference `images` (URL or base64) to guide the edit. Synchronous: the call blocks until the edited spritesheet is rendered and returns the same result shape as animateSprite (spritesheet URL, frame layout, optional GIF or individual frames). Credits are charged only on success, based on the produced duration and never more than the duration you requested. Pass an optional `request_id` to tag the result for later retrieval via `getSpriteResults`. Requires an API key (user scope). Credits: cost varies by model and duration (credits/sec): Forge 2/s (min 4); see this endpoint's full pricing table in the API docs.

  shallow
• editVideo

  Edit a previously generated video with a text prompt and optional reference images (video-to-video). Pass the video `url` you received from `createVideo`, `createVideoFromReferences`, or an earlier edit — it must be a video you generated within the last 7 days; arbitrary external videos are not accepted. Optionally add up to 5 reference `images` (URL or base64) to guide the edit. Synchronous: the call blocks until rendering finishes and returns the new video URL and its actual duration in seconds. Credits are charged only on success, based on the produced duration and never more than the duration you requested. Pass an optional `request_id` to tag the result so you can locate it later via `getVideoResults`. Related tools: `createVideo` to generate the source clip, `createVideoFromReferences` for reference-driven generation. Requires an API key (user scope). Credits: cost varies by model and duration (credits/sec): Eagle 2/s; see this endpoint's full pricing table in the API docs.

  shallow
• generatePose

  Re-pose an existing sprite into a new target pose while preserving the character, taking a source image (URL or base64), a pose name (or "Other" with a free-text description), and an optional n (1-4) for how many variations to produce. Only works with sprite image types (not icons, screenshots, etc.). Synchronous: the call blocks and returns an array of pose results, each containing the generated image url, the pose and description used, and a suggested motion_prompt tuned for that pose. Credits are charged only on success, scaled by the number of images generated. This is typically the first step before animating: call generatePose to set the character's pose, then feed the result (and its suggested motion_prompt) into animateSprite for the best animation quality; use rotateSprite instead when you want to change the camera angle rather than the pose. Pass an optional request_id to tag the results so you can locate them later via getSpriteResults. Requires an API key (user scope). Credits: This endpoint consumes 0.5 credits per result.

  shallow
• generateWithStyle

  Generate new images that match the visual style of a reference image: supply a style_image (URL or base64) plus a text prompt describing what to create and an image_type (defaults to sprite). Synchronous: the call blocks and returns an array of image results, each with a url; request n (1-4) to control the number of variations. The style_image is uploaded and validated, and an image larger than 15MB is rejected with HTTP 400. Credits are charged only on success, scaled to the number of images produced. Use this instead of createImage when style consistency with an existing asset matters; use editImage to alter the content of a specific image rather than borrow its style, and removeBackground to isolate a subject. Pass an optional request_id to tag the results so you can retrieve them later via getImageResults. Requires an API key (user scope). Credits: This endpoint consumes 0.5 credits per result.

  shallow
• get3DModelResults

  List 3D models you previously generated through the API, most recent first. This is a free read-only history lookup (no credits, no generation); it does not create anything. Pass an optional request_id query parameter to return only the results tagged with that id when you originally called create3DModel. Requires an API key (user scope).

  shallow
• getAccount

  Show your account's credit balance, plan and auto top-up settings. `credits.available` is what generations can spend right now (plan_credits + extra - used); `resets_at` is when the plan's monthly credits refill (unix seconds). When `team_pool` is true the balance is your team's shared pool, and `auto_topup` is null because the team owner manages it. Check this before an expensive generation instead of waiting for a 402. Buying credits and changing auto top-up happen in the web app at `billing_url`. This is a free read-only lookup (no credits, no generation).

  shallow
• getApiJob

  Poll the status of a generation job started by any tool. Every tool returns `{id, status}`; call getApiJob with that id until status is `succeeded` (then read `result`, shaped exactly like the tool's documented output) or `failed` (read `error`). Poll every few seconds, or pass `wait: 30` to long-poll - the call is held up to 30 seconds (max 60) and returns as soon as the job finishes.

  shallow
• getAudioResults

  List audio clips you previously generated through the API, most recent first. This is a free read-only history lookup (no credits, no generation); it does not create anything. Pass an optional request_id query parameter to return only the results tagged with that id when you originally called createSoundEffect, createAmbiance, createMusic, createAudioTransform, createVoice, createSpeech, or createSpeechPreset. Requires an API key (user scope).

  shallow
• getDocs

  Read Ludo's own guidance for a feature before you generate with it - how to choose a sprite animation mode, when to use Generate Before / Generate After, how margins behave, which model suits a job, and each generator's known limitations. This is the same documentation the Ludo web app shows its users, so it occasionally describes buttons rather than parameters; the substance applies to the API and MCP surfaces just the same. Call it with NO parameters first to get a table of contents - every document with its id, label and section titles, and no bodies - then call it again with `doc` (and optionally `sections`) to read only what you need. Fetching a whole document can return tens of thousands of characters, so prefer naming the sections. Section titles match case-insensitively, and an unknown `doc` or section title returns 400 listing the valid values so you can retry once. This is a free discovery endpoint: it does not charge credits and does not queue a job. Requires an API key (user scope).

  shallow
• getImageResults

  List images you previously generated through the API, most recent first. This is a free read-only history lookup (no credits, no generation); it does not create anything. Pass an optional request_id query parameter to return only the results tagged with that id when you originally called createImage, editImage, generateWithStyle, generatePose, rotateSprite, or removeBackground. Requires an API key (user scope).

  shallow
• getSpriteResults

  List spritesheets you previously generated through the API, most recent first. This is a free read-only history lookup (no credits, no generation); it does not create anything. Pass an optional request_id query parameter to return only the results tagged with that id when you originally called animateSprite or transferMotion. Requires an API key (user scope).

  shallow
• getVideoResults

  List videos you previously generated through the API, most recent first. This is a free read-only history lookup (no credits, no generation); it does not create anything. Pass an optional request_id query parameter to return only the results tagged with that id when you originally called createVideo. Requires an API key (user scope).

  shallow
• listAnimationPresets

  List the available animation presets along with their perspectives and the eight supported compass directions (N, NE, E, SE, S, SW, W, NW). Synchronous GET with no request body: it returns an animations array (each with id, name, category, description, duration, preview_url, and — when the preset can be retargeted onto a rigged 3D model — clip_url), a deduplicated perspectives array, and the directions list. This is a free discovery endpoint and does not charge credits. Use it to obtain the preset_id, perspective, and direction values that transferMotion needs, and to find motion preset names you can reference when animating; pair it with transferMotion (to apply a preset onto a sprite), animateSprite (text-prompt animation), or animate3DModelPreset (apply a clip_url-backed preset to a rigged 3D model). Requires an API key (user scope).

  shallow
• listApiJobs

  List the generation jobs you started through the API or MCP, most recent first. Web-app jobs are not included. This is a free read-only lookup (no credits, no generation). Filter with a comma-separated status list; limit defaults to 50 and is capped at 100. Requires an API key (user scope).

  shallow
• listDirectionalSpriteStyles

  List the styles Directional Sprites can render a 3D model in, with the perspectives (camera heights) and the eight directions they render from. Each style has an id (pass it as style_id), a label, a description, a family, whether it is pixel art, a thumbnail_url of the style at its defaults, its current version, and its settings: each setting has a name (the key in style_params), a kind (choice, bool or color - a color setting also takes any colour), its options ({label, value}) and its default. advanced_settings work the same way. Free discovery endpoint: it does not charge credits. Use it before previewDirectionalSprites, createDirectionalSprites and createDirectionalStills.

  shallow
• listGenerations

  List your generation history across the API and the web app - filter by type, source (api|web|all), text search, and date range. Returns {items, page, page_size, has_more}; keep paging while has_more is true. API-originated results expire after 7 days - download anything you want to retain. For an in-flight job's status use getApiJob instead.

  shallow
• previewDirectionalSprites

  Preview Directional Sprites: a few frames of a 3D model in a style, from each direction asked for, to check a style before rendering. Takes the same model, animation, camera and style fields as createDirectionalSprites. The response (synchronous, not a job) has one preview per direction, in the order asked, each with `frame_urls` - the frames as images (4 for an animated model, 1 for a still one) - and `render_3d`, the style and settings as rendered, which createDirectionalSprites takes back as they are. Free (no credits), and nothing is saved to your generations; the frame images are kept for 7 days. A preview takes several seconds. You run one preview at a time: starting another while one is still running cancels the older one, which then answers 204 with no body. Preview one or two directions while trying styles and render only once the look is right.

  shallow
• removeBackground

  Remove the background from a single image, returning the subject isolated on a transparent background. Supply the source image (URL or base64); optionally set crop to trim the result to the content, and creative_edit (default true) for higher-quality output that may not match the input pixel-for-pixel. Synchronous: the call blocks and returns a single image result with a url (not an array). The image is uploaded and validated, and an image larger than 15MB is rejected with HTTP 400. Credits are charged only on success. Use removeBackground for this dedicated cutout task; editImage can also remove backgrounds via a prompt but is better for broader edits, while createImage and generateWithStyle produce new images rather than process an existing one. Pass an optional request_id to tag the result so you can retrieve it later via getImageResults. Requires an API key (user scope). Credits: This endpoint consumes 0.5 credits per result.

  shallow
• rigModel

  Rig a 3D model: generate a skeleton and skin weights for an existing GLB so it can be animated. Accepts a URL or base64-encoded GLB in `model`. Synchronous: the call blocks while the rig is generated, then returns a downloadable `model_url` for the rigged GLB. rig_type selects the skeleton prior — general (default, any asset), humanoid (anime-style characters), game (classic game-character rigs), or the pinned humanoid templates for two-armed, two-legged characters: humanoid_template (standard 22-joint skeleton with named joints, required for animating from the preset library) and humanoid_template_hands (52 joints, five fingers per hand). joint_naming relabels the identified joints to a convention — smpl (default), mixamo, humanik, unreal, godot, rigify, or vroid — without changing the skeleton. Credits are charged only on success. Rigging is non-destructive to geometry but replaces any prior skeleton, so animations made against an old rig no longer apply. Requires an API key (user scope). Credits: This endpoint consumes 1 credits per call.

  shallow
• rotateSprite

  Re-render an existing sprite from a different camera viewpoint while keeping the same character and pose, taking a source image (URL or base64), a required camera_rotation azimuth (one of 0, 45, 90, 135, 180, -135, -90, -45 degrees), an optional camera_elevation (0, 30, or 60 degrees; omit to keep the current elevation), and an optional n (1-4) for the number of variations. Only works with sprite image types (not icons, screenshots, etc.). Synchronous: the call blocks and returns an array of rotate-sprite results, each with the generated image url and the camera_rotation and camera_elevation that were applied. Credits are charged only on success, scaled by the number of images generated. Use this to produce alternate view angles of a character; use generatePose instead to change the character's pose rather than the camera, and animateSprite or transferMotion to bring a sprite to life. Pass an optional request_id to tag the results so you can retrieve them later via getSpriteResults. Requires an API key (user scope). Credits: This endpoint consumes 0.5 credits per result.

  shallow
• rotateSpritesheet

  Re-render a previously generated sprite animation from a new view: the same motion and timing, seen from a different angle (e.g. a front-facing walk cycle turned into the same walk seen from the back). Pass the `spritesheet_url` you received from `animateSprite`, `animateSpriteKeyframes`, `transferMotion`, `editSpritesheet` or an earlier call - it must be a spritesheet you generated within the last 7 days; arbitrary external images are not accepted - and, as `image` (URL or base64), the character exactly as it must appear in the new view: it becomes the first frame of the animation. To produce that image, call rotateSprite on the animation's first frame (or any image of the character) and pick the view you want. An optional `final_image` fixes the last frame (it defaults to the first frame, for cyclic or returning animations), and an optional `prompt` steers the result: the character's facing in the new view ("its back to the camera"), where the action goes ("the kick goes to the left of the frame"), or anything else about the motion. Runs on hydra only. The job result is the same sprite result as animateSprite (`spritesheet_url`, `video_url`, grid fields, optional GIF and frame URLs). The animation covers the source's own length (up to 5 seconds; a longer source is sped up to fit), so omit `duration` unless you need to change that. Credits are held for that length when the job is accepted, and never less than the model's minimum charge (hydra generates at least 3 seconds, so 9 credits); the final charge is the model's rate × seconds of video generated, never more than was held, and the difference (or everything, if the job fails or is cancelled) is refunded. Pass an optional request_id to tag the result for later retrieval via listGenerations (type spritesheet). Async generation job: returns `{id, status}` - poll `getApiJob` (job and credit contract: see the server instructions). Credits: Cost varies by model and duration (credits/second × duration).

  shallow
• searchDocs

  Search Ludo's own documentation with a plain-language question and get back only the few sections that answer it - the fastest way to learn how a feature is meant to be used before you generate with it (how to pick a sprite animation mode or model, how margins behave, what something costs, known limitations). Start here rather than reading whole documents. Each result carries `doc` and `section`, which you can pass straight to getDocs to re-read that section, and the section's full markdown `content`. Results are best first; weak matches are left out, so an empty `results` list means the documentation does not cover the question - rephrase it, or call getDocs with no parameters to browse the table of contents. This is the same documentation the Ludo web app shows its users, so it occasionally describes buttons rather than parameters; the substance applies to the API and MCP surfaces just the same. Returns up to `n` sections (default 3, max 10). If it answers 503 the search backend is briefly unavailable: call getDocs instead rather than retrying in a loop. This is a free discovery endpoint: it does not charge credits and does not queue a job.

  shallow
• submitApiFeedback

  Report a problem with the Ludo API itself to the Ludo team. Use it ONLY for API bugs (an error, a failed or stuck job, a crash, a response that does not match this documentation) and API limitations (a parameter, operation or format you needed that the API does not support, and that you could not work around). NEVER use it to report model limitations or the quality of a result: an image, sprite, animation, 3D model, video or sound that looks wrong, ignores part of the prompt, has artifacts or is not what you wanted is not an API bug. Do not report those; retry with a different prompt, model or settings instead. Describe what you were trying to do and what went wrong, and name the operation (and job_id, when there is one) it relates to. Do not include personal data, secrets or file contents. Send one report per issue, and if you are an agent, tell the user what you sent. Free (no credits).

  shallow
• transferMotion

  Transfer motion from a reference video or a named animation preset onto a static sprite image, producing an animated spritesheet that mimics the reference movement. Provide the sprite as image (URL or base64) plus either a video URL or a preset_id together with perspective and direction. Synchronous: the call blocks and returns a single sprite result directly (spritesheet URL, plus optional GIF, individual frames, or with-background spritesheet when requested) with no polling step. It returns HTTP 400 if neither a video nor a complete preset_id/perspective/direction triple is supplied, if the named preset, perspective, or direction cannot be resolved, or if the model/duration combination is invalid. Credits are charged only on success, based on the spritesheet's actual produced duration (which may be shorter than requested if the reference video is shorter). Use this when you have an existing motion clip or preset to copy; prefer animateSprite to generate animation purely from a text prompt, and call listAnimationPresets first to get valid preset_id, perspective, and direction values. Pass an optional request_id to tag the result so you can retrieve it later via getSpriteResults. Requires an API key (user scope). Credits: cost varies by model and duration (credits/sec): Forge 2/s (min 4), Tango 4/s (min 4); see this endpoint's full pricing table in the API docs.

  shallow
• upscaleImage

  Upscale an image: the same picture at a higher resolution, up to 4x, with the result capped at 2048px on its longest side. The source image (URL or base64) must be below 2048px on its longest side; a larger one is rejected with HTTP 400. The job result is a single image result with a url (not an array). The image is uploaded and validated, and an image larger than 15MB is rejected with HTTP 400. Credits are held when the job is accepted and refunded if it fails or is cancelled. Use upscaleImage to raise the resolution of an image you already have; createImage and editImage make new or changed images instead. Pass an optional request_id to tag the result so you can retrieve it later via listGenerations (type image). Async generation job: returns `{id, status}` - poll `getApiJob` (job and credit contract: see the server instructions). Credits: This endpoint consumes 0.5 credits per result.

  shallow
• upscaleVideo

  Upscale a previously generated video to twice its resolution (2x). Pass the video `url` you received from `createVideo`, `createVideoFromReferences`, or `editVideo` — it must be a video you generated within the last 7 days; arbitrary external videos are not accepted. Only videos below 960x960 pixels can be upscaled (larger sources are rejected). Synchronous: the call blocks until upscaling finishes and returns the new video URL and its duration in seconds. Billed per second of video, independent of model, charged only on success. Pass an optional `request_id` to tag the result so you can locate it later via `getVideoResults`. Related tools: `createVideo` for image-to-video, `editVideo` to modify a generated video. Requires an API key (user scope). Credits: 0.2 credits per second of video.

  shallow
• validateApiKeyEndpoint

  Validates an API key. Returns 200 if valid, 403 if invalid.

  shallow

Embed this server’s score

Tool count and median score across every tool in this server’s corpus — honest in a way a single cherry-picked tool’s badge wouldn’t be.

[![Vouch score](https://vouch.tools/api/servers/bd804fde-a1c7-4773-b305-4e0cafb27c0c/badge.svg)](https://vouch.tools/servers/bd804fde-a1c7-4773-b305-4e0cafb27c0c)