Tutorials Motion

OBJ, FBX and STL: Which Format Holds a Character You Want to Animate

Beginner · ~18 min

A 1960s mid-century comic book style editorial illustration comparing 3D graphics file formats OBJ, FBX, and STL across wireframe mesh rendering and 3D printing workstations.

Overview

The three formats answer different questions. OBJ describes a surface. STL describes a solid for printing. FBX describes a scene, including the skeleton driving a character and the keyframes moving it. For a character you want to animate later, the choice among these three is FBX, because the other two have no way to represent a skeleton at all. Export a rigged character to OBJ or STL and the rig does not degrade. It disappears, without a warning, and you get a mesh frozen in whatever pose it happened to be in.

What You Need

The 3D application you modelled in, and its native save format
A clear answer to one question: are you handing this file to another program, or storing it for yourself
Enough disk space to keep more than one copy. Format choice is not either-or

Steps

Learn what each format physically contains

OBJ is a text description of a surface. Vertices, faces, normals and UV coordinates. Material definitions live in a separate .mtl file the OBJ only points at, so the two travel together or your model arrives grey. STL is simpler still. A list of triangles, each with vertex positions and a facet normal. No colour, no UVs, no materials. FBX is a scene container. Geometry, materials, textures, UVs, normals, skeletons, skin weights, keyframe animation, morph targets, cameras, lights and the hierarchy tying them together.

Understand what a missing feature does on export

A format lacking a feature does not approximate it. It drops it. Exporting a rigged and animated character to OBJ produces a single static mesh. The bones are gone. The skin weights are gone. The animation is gone. Nothing in the file records they ever existed. Exporting to STL loses all of the above plus your UVs and materials, leaving raw triangles. This is the single most expensive mistake in the area, because the export succeeds, the file opens, and the model looks correct until the day you try to move it.

Pick FBX when the file has to carry a rig between programs

FBX exists to move a scene from one application to another. Model in Blender and animate in Maya, or build a character in one tool and import it into Unreal or Unity, and FBX is the format doing the carrying. It holds the skeleton, the bone weights binding mesh to skeleton, blend shapes for facial work, and the keyframes. For a character you plan to animate, FBX is the only one of your three options able to hold the parts making animation possible.

Know where FBX breaks, because it does

FBX belongs to Autodesk. The specification is closed and the SDK is free to use rather than open. Two practical consequences follow. The format has ASCII and binary variants, and support differs by application. Blender dropped ASCII FBX import at version 2.8. And FBX is versioned, so an exporter writing FBX 7.5 with 64-bit block headers needs a 2016-or-later application at the other end. When an FBX import fails or arrives with a broken rig, the version is the first thing worth checking. Export an older version and the same file often lands cleanly.

Use STL and OBJ for the jobs they are good at

STL is the format for 3D printing. A slicer needs a watertight solid and nothing else, so the absence of materials and rigging is a feature rather than a gap. If you print in colour, use 3MF instead, because STL has no way to record colour. OBJ is the format for handing static geometry to someone whose software you do not know. It is old, plain text, and nearly universally readable. Sculpt exports, photogrammetry output and set dressing all move around fine as OBJ.

Save your native project file as the real archive

FBX answers the interchange question. It is a poor answer to the archive question. Your .blend, .ma, .mb or .max file holds things no interchange format carries: your modifier stack, procedural materials and node graphs, constraints, drivers, custom bone shapes, and the control rig you built to make animating bearable. FBX bakes what it understands and drops the rest. If you want a character you find usable in two years, the file to keep is the one your software wrote natively. Export FBX from it whenever a second program needs the character.

Consider glTF as the modern open option

You asked about three formats. A fourth deserves a mention. glTF 2.0 is a royalty-free open standard from the Khronos Group, built for delivering 3D at runtime. It supports vertex skinning through joint influences, so it carries skeletal animation the way FBX does, and its specification is public. glTF is strong for the web, for real-time viewers and for anything shipping to an engine or a browser. It is weaker as an authoring exchange between content applications, where FBX still moves more data more reliably. Use both where the pipeline benefits.

Pro Tips

An export succeeding tells you nothing about what survived. Reimport your FBX into a fresh scene and check the skeleton, the weights and one animated frame before you delete anything.
Ship OBJ and MTL files together, along with the texture images the MTL names. An OBJ arriving alone renders grey and the sender rarely notices.
When an FBX rig imports broken, try exporting an older FBX version before rebuilding anything. Version mismatch causes more of these failures than bad rigging does.
Scale and axis conventions differ between applications. Blender treats Z as up while Maya treats Y as up. Set the export options deliberately rather than accepting defaults, or your character arrives lying on its back at a hundredth of its size.
STL files store no unit information. A model exported in millimetres and read as inches prints at the wrong size, and the file gives the slicer no way to know.
Name your exports with the format and the date. A folder holding character.fbx, character_v2.fbx and character_final.fbx costs you an hour every time you return to it.

Knowledge Base

What You'll Learn

The table below is the short version. The sections after it cover what the table cannot show, which is what happens to your data during an export.

What each format stores

	OBJ	FBX	STL	glTF 2.0
Geometry	Yes	Yes	Triangles only	Yes
UV coordinates	Yes	Yes	No	Yes
Materials	External .mtl	Embedded	No	Embedded, PBR
Textures	Referenced	Embedded or linked	No	Embedded or linked
Skeleton and rig	No	Yes	No	Yes
Skin weights	No	Yes	No	Yes
Animation	No	Yes	No	Yes
Blend shapes	No	Yes	No	Yes
Cameras and lights	No	Yes	No	Yes
Scene hierarchy	No	Yes	No	Yes
Open specification	Yes	No	Yes	Yes
Best at	Static geometry exchange	Rigged and animated scenes	3D printing	Runtime and web delivery

Why the answer for your character is FBX, with one caveat

Of the three formats you asked about, one holds a skeleton. The comparison ends there for an animated character, because a format with no representation for bones cannot store a rig in any partial or degraded form.

The caveat is the word saving. FBX is built for moving a scene between applications, and it does the job by baking your setup into a form both ends understand. Baking loses your procedural work. Your node-based materials become flat texture assignments. Your constraints and drivers are resolved and dropped. Your control rig, the layer of custom shapes and limits making the character animatable by a person, does not survive at all, because it exists as software-specific rigging logic rather than as bones and weights.

So save two files. The native project file is your character. The FBX is a copy formatted for somebody else's software. Treat the FBX as disposable output you regenerate rather than a master you rely on.

Reading an export dialog properly

Most rig damage happens in the export options rather than in the format. Four settings deserve attention every time.

Axis orientation. Blender uses Z-up. Maya, Unity and most engines use Y-up. Setting this wrong lays your character on its back.
Scale. Applications disagree about what one unit means. A character exported at the wrong scale arrives enormous or microscopic, and fixing it after rigging causes more problems than setting it correctly.
What to include. Exporters let you choose armature, mesh, animation and cameras separately. An FBX exported with the mesh but not the armature contains no rig, and the export still reports success.
Apply modifiers or not. Applying bakes your subdivision and other modifiers into the mesh. Not applying means the receiving software sees the base cage. Both are correct answers to different questions.

Verify by reimporting. Open the FBX in a new scene, move one bone, and scrub one second of animation. Sixty seconds of checking prevents the failure discovered a month later.

Which to hand over, by situation

You are	Use	Because
Storing a character to animate later	Native file, plus FBX	Native keeps the rig logic. FBX makes it portable.
Sending a rig to an animator	FBX	Carries skeleton, weights and blend shapes.
Importing into a game engine	FBX or glTF	Both carry skinning. Engines read both.
Publishing to a website or viewer	glTF or GLB	Built for runtime delivery, compact, open.
Sending static geometry to an unknown tool	OBJ	Text, ancient, read by almost everything.
3D printing in one colour	STL	A slicer needs a solid and nothing more.
3D printing in colour	3MF	STL has no way to record colour.

Where This Fits

This sits under Blender for Motion Graphics, the pillar for the 3D and motion side of the site. A History of Animation covers how the discipline arrived at skeletal animation, and Media File Naming covers the versioning habits keeping a folder of exports usable.

FAQ

Q: Which format should I use for a character I want to animate later?
A: FBX, of the three you asked about. OBJ and STL have no representation for a skeleton, so they discard the rig on export. Save your native project file alongside it, because FBX bakes procedural materials, constraints and control rigs rather than preserving them.

Q: Does OBJ support animation in any form?
A: No. OBJ describes one static surface. Some pipelines fake motion with a numbered sequence of OBJ files, one per frame, which produces large folders and no skeleton. It is a workaround for point-cache data rather than a way to store a rigged character.

Q: Why did my FBX import with no bones?
A: Two usual causes. The exporter had the armature unticked, so the file genuinely contains no skeleton. Or the FBX version is newer than the importer reads. Re-export with the armature included and try an older FBX version.

Q: Is glTF better than FBX?
A: For delivery, often. glTF is open, compact, and built for runtime and web use, and it carries skinned animation. For moving work between content applications during production, FBX still transfers more reliably. The two answer different questions and using both is normal.

Q: Is it possible to turn an STL back into an animatable character?
A: Not usefully. An STL holds triangles with no UVs, no materials and no skeleton. You would retopologise the mesh, lay out new UVs, rebuild the textures and rig it from nothing, which is most of the modelling work over again.