SVG to Lottie

Turn an SVG into Lottie JSON that actually renders everywhere. The usual complaint about these converters is that the output previews fine in a browser and then comes out wrong, or blank, in Android Studio — which happens because lottie-web is far more permissive than the mobile renderers, so a converter that checks itself by previewing in lottie-web has verified nothing about Android. This one converts every arc and quadratic into cubic beziers (Lottie has neither), bakes every transform into the coordinates rather than nesting them, and writes tangents relative to their vertices, which are the three things that make all four renderers agree. Anything with no faithful Lottie equivalent — filters, clip paths, text, embedded images — is listed with exactly which renderers it breaks and what was done instead. Nothing is uploaded.

What survives the conversion

SVG featureResult
Paths, arcs, quadraticsConverted to cubic beziers
Nested transformsBaked into coordinates
Linear / radial gradientsMapped to Lottie gradient fills
Clip path / maskDropped — breaks Android, iOS, RN
FilterDropped — no Lottie equivalent
TextSkipped — outline it first
Embedded imageSkipped

When to use it

  1. Get a logo into a Lottie pipeline as a starting point for animation.
  2. Convert an icon set for a mobile app that renders Lottie.
  3. Produce a Lottie that works in Android Studio, not just in a browser.
  4. Turn an illustration into editable Lottie shapes.
  5. Check which parts of an SVG will survive the trip before committing to it.

How to Use

  1. Drop in or paste your SVG.
  2. Check the compatibility list for anything that will not survive.
  3. Compare the two previews, then download the JSON.

Features

  1. Arcs and quadratics converted to cubic beziers
  2. Transforms baked into coordinates, not nested
  3. Tangents stored relative to their vertices
  4. Linear and radial gradients with object-bounding-box units
  5. Rect, circle, ellipse, line, polygon, polyline, path and use
  6. Per-renderer compatibility checklist
  7. Side-by-side SVG and Lottie preview
  8. Runs entirely in your browser

FAQs

Why does my converted Lottie break in Android Studio?

Usually because the converter left an arc or a quadratic in the path data, nested the transforms instead of baking them, or used a clip path or filter. lottie-web renders around all of that; lottie-android does not. This tool converts the curves, flattens the transforms, and tells you up front which renderers each remaining feature breaks.

Is the result animated?

No — this is the static conversion, a single-frame Lottie carrying the geometry. It is the right starting point for animating in an editor or through a Lottie pipeline. For an SVG that already animates, the Animated SVG to Lottie tool maps the keyframes.

What does cross-platform mode do?

It reports, per renderer, whether the output will draw faithfully, and lists any feature that will not with what was done about it. The geometry discipline — cubics, flattened transforms, relative tangents — is applied always, because there is no reason to produce output that only works on the web.

Are gradients supported?

Linear and radial, with their stops and opacity. The detail that catches converters out is that gradientUnits defaults to objectBoundingBox, meaning the coordinates are fractions of the shape's own bounding box rather than user units — resolve them against the canvas instead and the gradient lands somewhere else entirely.

What about text?

It is flagged and skipped, deliberately. Lottie text needs the font present on the device and renders differently on every platform. Convert text to outlines in your design tool and re-export; then it is geometry and it converts faithfully.

Why did my file come out empty?

Most often it was all text, all images, or had no viewBox. The tool says which. If it had no width, height or viewBox there is genuinely no way to know how big it should be, so it asks rather than guessing.

Does it handle <use> and symbols?

Yes — <use> references are resolved and drawn in place. Icon sets lean on it heavily, and a converter that skips it produces an empty file from a perfectly good SVG.

Is my SVG uploaded?

No. It is parsed, converted and previewed in your browser.

Technical Details

The complaint that makes this tool worth building is that converted files preview correctly in lottie-web and then draw wrong, or blank, in Android Studio. That is not a bug in Android — lottie-web is by far the most permissive of the four renderers, so a converter that checks its own output by previewing it in lottie-web has verified nothing about anywhere else. Three disciplines produce output all four agree on. First, every curve becomes a cubic bezier, because Lottie's shape model has no arcs and no quadratics at all: an `A` command left unconverted is dropped or guessed at differently by each renderer, which is what a rounded rectangle arriving with sharp corners actually is. Arcs go through the endpoint-to-centre parameterisation from SVG 1.1 appendix F.6 and are then split into one cubic per quarter turn or less, since a single cubic cannot approximate more of an ellipse to a useful tolerance; quadratics are raised exactly rather than approximated, by placing both cubic controls two thirds of the way from each endpoint toward the quadratic's control. Second, every transform is multiplied into the coordinates rather than emitted as a Lottie group transform. Lottie can carry a transform per group, but nested transforms with differing transform-origin semantics are exactly where Android and iOS diverge, so the safe output has none — and the flattening has to compose in SVG's order, where listed transforms apply right to left, or every nested group ends up mirrored and displaced. Third, tangents are written relative to their vertex. This is the single most common mistake in a hand-rolled converter and it does not fail loudly: absolute control points render as a spray of spikes radiating from the origin. A closed path also does not repeat its first vertex, because the closing segment is implied and a duplicate point leaves a zero-length edge some renderers draw as an artefact. Everything else is detail that still breaks files: `d` attributes where `10-5` is two numbers and a repeated `M` is an implicit lineto; a viewBox whose origin is not zero, which crops the artwork if ignored; `stroke-width` that has to scale with the geometry it was already scaled with; gradients whose default `gradientUnits` is objectBoundingBox, meaning the coordinates are fractions of the shape's own box rather than user units; and `<use>`, which icon sets lean on so heavily that skipping it produces an empty file. Features with no faithful equivalent — filters, masks, clip paths, embedded rasters, text, patterns, markers — are listed with the renderers each one breaks and what was done instead, rather than emitted and left to fail differently on every platform.

Lottie & Animation Tools

Lottie & Animation Tools

  • Lottie to WebM
  • Lottie to MOV
  • Lottie to PNG Sequence
  • Lottie to APNG
  • Lottie Metadata Viewer
  • Lottie Accessibility Analyzer
  • Lottie Optimizer
  • Lottie to dotLottie