Get plain Lottie JSON back out of a .lottie file. Drop the container in and every animation inside it is listed with a live preview, ready to download individually or all at once. Turn on re-inlining and any images the container carried are folded into the JSON as data URIs, so the result is a single self-contained file rather than a .json that renders with holes because the folder it expected is gone. It is deliberately tolerant: containers with a wrong or missing manifest still open, because plenty of files in circulation have one and play everywhere. Nothing is uploaded.
| Option | Result |
|---|---|
| Plain extract | The JSON exactly as it was packed |
| Re-inline images | One self-contained .json, larger |
| Download all | A ZIP of every animation |
| No manifest | Still opens, with a warning |
Because plenty of things still expect it: lottie-web on its own, older Android and iOS integrations, and most editing tools — including the colour editor and optimiser here. A .lottie is better for shipping; a .json is better for working on.
Inside a container an image is a separate file the player resolves relative to the archive. A loose .json has no archive, so those references break. Re-inlining folds each image into the JSON as a base64 data URI, giving you one self-contained file. It makes the file larger — that is the trade.
Yes. The manifest is treated as a hint rather than a requirement: every JSON in the archive is read and checked regardless, and you are told the manifest was missing. Plenty of real files are like this and play fine everywhere.
All of them are listed, each with its own preview and download, plus a download-all as a ZIP. They are shown in manifest order rather than the alphabetical order the zip enumerates in, so a two-animation bundle does not come out backwards.
Because it was valid JSON but not a Lottie — a settings file or a stray package.json, for instance. It is named in the warnings rather than handed to a renderer that would fail obscurely.
No. The zip is read in your browser.
Byte for byte, unless you turn on re-inlining, which by definition rewrites the asset entries. The animation data itself is untouched either way.
Unpacking is a zip read, and the interesting decisions are all about how strictly to trust what is inside. The manifest is treated as a hint rather than as truth: plenty of .lottie files in circulation were produced by tools that write an id the animation file is not actually named after, or that omit the manifest entirely, and those files play perfectly well in every dotLottie player. So every `*.json` in the archive other than the manifest is read regardless of what the manifest says, each is checked against the Lottie shape before being offered, and anything that is valid JSON but not an animation — a settings file, a stray package.json — is skipped with its name reported rather than handed to a renderer that would fail obscurely. The manifest is then used for the one thing it is reliable for: ordering. Zip entries enumerate alphabetically, which is not authoring order, so a two-animation bundle would otherwise come out backwards. The other half of the job is images. Inside a container an image asset is a relative path resolved against the archive; a plain `.json` handed to a player has no archive to resolve against, so extracting without doing anything about it produces an animation that renders with holes. Each entry under `images/` is read as base64, given the media type its extension implies, and folded back into the matching asset as a data URI with its `u` prefix cleared and `e` set to 1. The match is on the bare filename rather than the full path, because the folder inside the zip and the `u` prefix written in the JSON do not have to agree and frequently do not. Anything that cannot be matched is named rather than left as a silent gap. Everything runs in the page.