glTF, GLB or FBX in — USD, USDZ, GLB or FBX out, with proof

Give it a URL to a .glb, .gltf or .fbx, pick any of six output formats, and get back a complete asset — textures included, every animation clip intact — plus a report on what shape the file is really in and whether the rig actually survived the trip. Headless Blender 4.5 LTS underneath. No UI, no login, built to sit inside a pipeline, callable by agents over MCP.

The source format is detected from the file's bytes, not its extension. A URL can be called anything; the file cannot lie about its own header.

The thing most converters get wrong

"Did it convert?" is the easy question. Every converter answers it.

The question that actually costs you an afternoon is different: the file came out, so why does it break in my slicer / look wrong in Unreal / arrive at 100× scale / show up untextured? That depends less on the conversion than on what you're about to do with the asset.

So instead of a pass/fail badge, each run tells you what the asset is ready for:

Box.glb          DamagedHelmet.glb
realtimeEngine       READY            READY
texturing            NOT READY        READY
csgBoolean           READY            NOT READY
threeDPrinting       READY            NOT READY

DamagedHelmet is great in an engine and hopeless in a slicer — an open shell with a few non-manifold edges. Box is a clean watertight cube you could print tomorrow, shipped with no UVs at all. Both facts are useful. Neither shows up in an exit code.

Rigs are verified, not assumed

For anything skinned or animated, the Actor exports the file and then imports it back and compares the result against the source. Not "an armature exists" — the actual numbers:

• every bone name and its parent
• bone head positions, compared strictly
• skin weights, per vertex, per influence
• the rig evaluated in motion, sampled per animation clip across each clip's own frame range

On the Khronos Fox.glb: 24/24 bones, identical hierarchy, 1 728 vertices with zero weight mismatches. On a Mixamo character (Samba Dancing.fbx, 67 bones, two skinned meshes, 97 vertex groups): everything intact through an FBX round-trip.

And the verification is honest about its own limits, which matters more than it sounds. Formats rename animations, keep only one clip, or resample curves — so the pose check reports one of four explicit statuses instead of a fake boolean: identical, within-resampling-tolerance, unalignable (nothing to compare across this format boundary — structure and weights were still fully verified), or deviation-found. Only the last one counts against the verdict. A checker that cries wolf on a perfect rig is worse than no checker, and the first version of this one did exactly that until it was tested against reality.

Two genuine catches from that testing, left here because they are exactly what you'd want this tool to tell you:

• routing that same Mixamo character through USD loses skin-weight fidelity — the report flags skinWeightsIdentical: false instead of letting you find out in the engine;
• a glTF→glTF round-trip resamples animation beyond codec tolerance on some rigs, and gets flagged as deviation-found.

One Blender-specific note the report also makes for you: bone tails are a Blender display concept, rebuilt on every import — glTF, FBX and USD store joints as transforms. Tail differences are listed as information, never as damage. Bone heads are what's compared strictly.

FBX is written for studios, not for previews

Blender's FBX exporter defaults quietly lose data, and every one of them is overridden here:

Setting	Blender default	This Actor	Why it matters
mesh_smooth_type	OFF	FACE	no smoothing groups is the #1 Blender-FBX complaint in Maya/Max
use_tspace	off	on	no tangents → normal maps light wrongly
use_custom_props	off	on	the importer reads them; the exporter was throwing them away
add_leaf_bones	on	off	stops Blender inventing bones your rig never had
bake_anim_simplify_factor	1.0	0.0	lossless animation curves
embed_textures	off	on	one self-contained deliverable

Every animation take ships inside the one FBX (bake_anim_use_all_actions). On import, the same care applies in reverse: no automatic bone reorientation, no baked-in transforms, Maya pre/post rotations preserved.

The report lists these choices under exportSettings, so you can see what was decided rather than trusting that something was.

Every animation clip survives — per format, the right way

USD binds one SkelAnimation per skeleton, and Blender's exporter only writes the active action — so a glTF carrying three clips would silently lose two. For USD outputs, each clip is therefore exported as its own file alongside the base asset (CLIP_Survey, CLIP_Walk, CLIP_Run for the Fox). FBX and GLB carry every take natively in the single file, so no side files are emitted there — that would just ship duplicate data.

Either way, completeness.allAnimationClipsDelivered tells you explicitly that what went in came out.

Textures come with the file

Blender writes referenced textures into a sibling directory rather than embedding them. Ship only the model file and every material points at something that doesn't exist. So when a conversion produces more than one file you get a ZIP preserving the relative layout, and everything resolves. DamagedHelmet delivers 3.16 MB — USD plus its four textures — instead of 1.13 MB of dangling references.

Shortcuts: usdz bundles textures inside the file itself (the same helmet comes back as one self-contained 3.98 MB .usdz, ready for Quick Look), and fbx embeds media too.

Two details that trip naive validators

Split vertices aren't damage. glTF gives a vertex its own copy whenever it needs a second normal or UV, so a plain cube arrives as 24 vertices in six disconnected quads — and a naive topology check reports a perfect cube as 24 non-manifold edges. This Actor welds coincident vertices before classifying topology, then separates genuine non-manifold edges from ordinary open boundaries.

Scale and axis bite everyone eventually. glTF says Y-up, metres. Blender rotates to Z-up on import. USD carries its own upAxis and metersPerUnit. Every report spells out the conversion chain, the asset's real dimensions, and whether that size looks sane for something a human would build.

Input

Field	Type	Required	Default
glbUrl	string	yes	—	Public URL to a .glb, .gltf (embedded buffers) or .fbx (embedded media), up to 200 MB
outputFormat	string	no	usdc	usdc, usda, usd, usdz, glb, fbx
verifyRoundTrip	string	no	auto	Re-import and compare. auto runs whenever the asset is rigged or animated
exportAllClips	boolean	no	true	One USD per clip (USD outputs only; FBX/GLB don't need it)
strictValidation	boolean	no	false	Bail out with no conversion charge when the file is genuinely broken

What comes back

The deliverable is under OUTPUT in the run's key-value store — a ZIP when there's more than one file, the bare file otherwise, with outputKind telling you which. The dataset record carries status, a manifest of every file shipped, clipOutputs, and the full report: readiness verdicts, per-check severities with plain-language meanings, scene stats, the axis/unit block, clip completeness, and — for rigged assets — the round-trip rig comparison with its verificationCompleteness breakdown. The unabridged report lives under REPORT_FULL.

Billing

One conversion-completed event per run that hands you a file. Failed download, Blender crash, strict-mode rejection: no conversion event charged. If the billing call itself ever fails, your conversion still completes — losing a good result over an accounting hiccup would be absurd.

Verified against

Every cell of this matrix executed end-to-end on Apify, not assumed:

Source	→ usdc	→ fbx	→ glb
Fox.glb (rigged, 3 clips)	rig intact	rig intact	pose deviation flagged
Samba Dancing.fbx (Mixamo, 67 bones)	weight loss flagged	rig intact	—
BrainStem.glb (rigged)	rig intact	rig intact	—
DamagedHelmet.glb (5 textures)	✓ + textures	✓ 2.07 MB	—
Box.glb, ABeautifulGame.glb (1.5 M tris)	✓	—	—

The Docker build refuses to finish unless Blender starts headless and every importer/exporter this Actor depends on actually exists — an operator rename in a future Blender breaks the build here, not a run on your side.

Where it's still thin

Multi-file sources (a .gltf with external .bin, an .fbx referencing loose textures) won't find their siblings — only self-contained files work. Material fidelity is not verified: the round-trip compares structure and deformation, not shader graphs. Pose verification across format boundaries is sometimes unalignable (formats rename or merge clips) — structure and weights are still checked, and the report says exactly which parts were verifiable rather than pretending. No production character with UDIM tiles and facial blendshapes has been through it yet; the reference set is Khronos plus Mixamo.