Animated SVG to Lottie

Turn an animated SVG into a Lottie with real keyframes. It reads both animation systems SVG actually uses — SMIL elements like animate and animateTransform, and CSS @keyframes with animation rules — and maps transforms, opacity, colours and stroke widths onto per-element Lottie layers, with the easing carried across rather than flattened to linear. The detail that decides whether the result looks right is the rotation pivot: SVG turns about the element's own origin or a stated centre, Lottie turns about a layer anchor, and if the pivot is not carried through the same matrix the geometry was baked with, the shape swings around the corner of the canvas instead of spinning on the spot. Anything that cannot be carried faithfully is named, with what was done instead. Nothing is uploaded.

What converts

SourceResult
animateTransform rotate / scale / translateLayer transform keyframes with the right pivot
animate opacity / fill / strokeKeyframes on the layer or the paint
CSS @keyframes transform / opacity / fillThe same, matched by selector
keySplines, cubic-bezierKeyframe in and out tangents
steps(), calcMode discrete, setHold keyframes
animateMotion, d morph, skew, matrix()Flagged with what was done instead
JavaScript animationNot readable from the file

When to use it

  1. Author in SVG and CSS but ship through a Lottie pipeline.
  2. Get a CSS-animated loader into a mobile app.
  3. Convert a SMIL animation for a platform that does not support SMIL.
  4. Turn a hand-coded SVG animation into something a designer can edit.
  5. Check what of an animation will survive before committing to Lottie.

How to Use

  1. Drop in or paste your animated SVG.
  2. Set the frame rate, and a duration if you want to override the one it found.
  3. Compare the two previews, check the report, then download.

Features

  1. SMIL animate, animateTransform and set
  2. CSS @keyframes matched by selector
  3. Transform, opacity, fill, stroke and stroke-width
  4. keySplines and cubic-bezier easing mapped to keyframe tangents
  5. Rotation and scale pivots carried through the real matrix
  6. One layer per element, so effects and animation have somewhere to live
  7. Gaussian blur and drop shadow as Lottie effects
  8. Per-renderer compatibility report
  9. Runs entirely in your browser

FAQs

Which animation does it read?

SMIL — animate, animateTransform and set — and CSS @keyframes driven by animation or the animation-* longhands, matched to elements by selector. Both in the same file is fine.

Why do other converters make my shape fly around the corner?

The pivot. SVG rotates about the element's own origin or a centre written after the angle; Lottie rotates about a layer anchor. If the converter does not carry that pivot through the same transform the geometry was baked with — and move the layer position with it — the shape orbits the canvas origin. That is the single most common symptom, and it is what this tool exists to get right.

Is the easing preserved?

Yes, where it can be. SMIL keySplines and CSS cubic-bezier both describe a cubic with two control points, which maps directly onto a Lottie keyframe pair — the first control becomes the out-tangent of the keyframe being left, the second the in-tangent of the one arrived at. Step easing becomes hold keyframes.

What happens to an infinite animation?

One repetition becomes the Lottie's length and you loop the player, which is the faithful translation. Padding it to some arbitrary duration instead leaves a visible stutter where the repeats meet.

Does it handle blur and gradients?

Yes. Linear and radial gradients come through the geometry pass, and a feGaussianBlur or feDropShadow becomes a real Lottie layer effect rather than being dropped — honoured by lottie-web and recent lottie-android, ignored by lottie-ios and React Native, which the report tells you.

What about path morphing?

Flagged rather than faked. Lottie can morph an outline only when both states have the same number of vertices, and silently resampling someone's artwork to force that is worse than saying so.

Will JavaScript-driven animation convert?

No, and nothing in a browser can do it from the file alone — that animation exists only while the script runs. The tool says so when it sees a script rather than producing a still and calling it converted.

Is my file uploaded?

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

Technical Details

Geometry goes through the static converter first, which is what makes any of this possible: it emits one Lottie layer per drawable element, so each element has somewhere of its own to carry keyframes and effects. Two problems then dominate. The first is the pivot, and it is the most visible failure of a naive animated conversion. `animateTransform type="rotate"` turns about the origin of the element's own coordinate system, or about an explicit centre written after the angle; Lottie turns about a layer's anchor point. Because the static pass bakes every parent transform into the coordinates, the geometry is already in canvas space — so the pivot has to be carried through that same matrix, and the layer's position has to move with its anchor. Miss either and the shape swings around the top-left corner of the canvas instead of turning on the spot. A translation is handled the other way round: it is a direction rather than a place, so it goes through the matrix's linear part only, because running it through the full matrix adds the matrix's own offset and moves the element twice. The second problem is easing. SMIL `keySplines` and CSS `cubic-bezier()` both describe a cubic with two control points, and so does a Lottie keyframe — but Lottie splits it across two keyframes, storing the first control as the out-tangent of the keyframe being left and the second as the in-tangent of the one arrived at. Writing both onto one keyframe parses, plays, and is wrong everywhere by a little, which is the hardest kind of error to be told about. Linear is written out explicitly too, since Lottie's default is not linear. Around those: clock values are read in every form SMIL allows, because a parser that only understands `2s` reads `500ms` and `1:30` as zero and collapses the animation onto frame one; an indefinite repeat becomes a loop of one repetition rather than an arbitrary padded length, which is what avoids a stutter at the seam; a repeat's first value is not re-emitted, because it sits exactly where the previous repetition ended; and a group's animation is applied to every layer built from inside it, which is what grouping means. Colour and stroke-width animate on the paint item rather than the layer. Blur and drop shadow survive as real Lottie layer effects. What cannot be carried — motion paths, path morphs, skew, CSS matrix and 3D transforms, and anything driven by JavaScript — is named with what was done instead, rather than emitted and left to fail differently on each renderer.

Lottie & Animation Tools

Lottie & Animation Tools

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