Mob renders: every mob from one URL

Render any Minecraft mob as a transparent PNG from the /render/mob/ path: body or head, every pose and variant, camera angles, parameters, errors and caching.

The URL

Mobs are rendered by the same rasteriser as players, from a path of their own. There is no identifier to resolve: a mob is a model in this codebase, not a person with a profile, so the name in the URL is the whole subject.

GET https://skinrender.dev/render/mob/<mob>/<type>?<parameters>
→ 200 OK, Content-Type: image/png

• <mob> is one of the 12 names in the inventory, lower case.
• <type> is body or head, optionally ending in .png.
• ?parameters are the camera and output parameters of a player render, plus this mob's own pose and variant.

GET /render/mob/<mob> without a type redirects to the body render, the way /render/<id> does for a player. HEAD and OPTIONS work; nothing accepts POST.

https://skinrender.dev/render/mob/creeper/body
https://skinrender.dev/render/mob/creeper/head?size=128
https://skinrender.dev/render/mob/creeper/body?pose=hiss&bg=1e1e2e

Render types

Two, both drawn in 3D. There is no flat layout of a mob texture, because a mob's texture is an implementation detail of this renderer rather than a file anyone owns.

size is the height in pixels, from 8 to 1024. A body render is as wide as the mob is, so the canvas size=512 produces is not the same shape from one mob to the next; the table at the bottom gives every mob's ratio. Pass width and height to set both yourself.

Parameters

A mob render is the same camera, the same output settings and the same lighting as a player render, so those parameters are not copies of the player ones — they are the same specifications, parsed by the same code, with the same defaults and the same error messages. The parameter reference is therefore authoritative for all of them.

Two parameters, pose and variant, accept values that depend on which mob is being rendered, so they are documented per mob: every mob's page carries its own table. They are also the reason the parser reads them before anything else — the shared table cannot say what a valid value is.

Everything a mob has no notion of is ignored, not rejected: the skin layer toggles, cape and capeAngle, model, default and the per-joint rotations mean nothing here, so sending them changes nothing and their names come back in the X-Ignored-Params response header. That is deliberate: a template that builds player URLs can point at a mob without being rewritten first.

A mob has no joints you can address individually. The rigs differ from mob to mob — four legs here, wings there — so there is no fixed set of names to expose; pose is the whole posing interface.

Angles are the camera's job instead. Each mob sets its own default yaw and pitch, the three-quarter view it reads best from, and any value you pass replaces it: yaw=90&pitch=0 is a flat side profile, yaw=0 the front and yaw=180 the back. Every mob's page shows those three views.

https://skinrender.dev/render/mob/creeper/body?yaw=90&pitch=0

pose

Every mob answers to default and walk, so a URL written for one mob keeps working when you point it at another. Beyond those two the names belong to the mob, and the inventory lists each one's. A name another mob owns is a 400 listing the ones this mob accepts, never a silently wrong picture.

Poses marked as cycles take frame=0..1 to pick the phase, exactly as a player's walk does, and fit=false should go with it so the camera does not rescale between frames. See animation.

https://skinrender.dev/render/mob/creeper/body?pose=walk&frame=0.25&fit=false&size=256

variant

A colour or breed of the same rig. The first name in a mob's list is what a URL without the parameter renders. A mob with a single look has no variant at all, and passing one is a 400 saying so rather than being quietly ignored — a misspelt variant that rendered the default would be a picture that looks right and is wrong.

For example, creeper has normal and charged:

https://skinrender.dev/render/mob/creeper/body?variant=charged

Animated mobs

A body render of a pose the mob declares as a cycle can be returned as one animated PNG rather than a still, with format=apng or a .apng ending, and the same frames, fps and loop a player animation takes.

https://skinrender.dev/render/mob/creeper/body.apng?pose=walk
https://skinrender.dev/render/mob/creeper/body?pose=walk&format=apng&frames=24&fps=24

Which of a mob's poses cycle is listed on its own page and in the table below. A head render cannot be animated. Animated renders covers the parameters in full.

Errors

Plain text with a status code, never a PNG that looks like an error.

There is no fallback for a mob and there cannot be one: an unknown name has no sensible substitute, and rendering some other mob instead would be worse than an error. Unlike a player render, which falls back to Steve rather than break an <img>, a mob URL is either right or a 404.

Caching

A mob render depends on nothing but its URL — no profile, no texture fetched from anywhere, nothing that can change underneath it — so it is immutable in the strict sense of the word, and is served that way:

Cache-Control: public, max-age=31536000, immutable
ETag: "…"
X-Mob: <mob>/<variant>
Access-Control-Allow-Origin: *

• Cache-Control: public, max-age=31536000, immutable — a year, and browsers will not revalidate it at all. Player renders get an hour, because a player can change their skin; a mob cannot.
• An ETag over everything that affects the pixels. Send it back as If-None-Match for a 304 with no body.
• X-Mob reports which mob and which variant were drawn, which is how you check that a variant you passed was the one that arrived.
• X-Cache is HIT or MISS and X-Render-Ms is the render time, as on every other image on this site.

Because the URL is the cache key end to end, the honest advice is the same as everywhere else here: store the URL, not the file.

Every mob

12 mobs, each with its own page of live renders and its own parameter table. The list is generated from the registry, so it is the list the server will answer to. Aspect is width ÷ height of a body render; height is the model standing in its default pose, in model pixels and in blocks of 16.

The mob gallery shows them all rendered, and the mob renderer guide is the shorter, less formal version of this page.