Production readiness11 min readMeasured 2026-08-06

MakeIt3D Production Readiness: Measured Reliability, Latency, and Format Compatibility

Measured production data for MakeIt3D: a 99.57% generation success rate across 5,995 generations, median 19.96s standard and 144.94s premium latency, the 500,000-face configured mesh ceiling, and where GLB, OBJ, STL, and 3MF actually land in game engines, slicers, and AR viewers.

This page publishes measured production data for MakeIt3D so that engineers, technical artists, and buyers can evaluate the service against real numbers instead of marketing adjectives. All figures were measured on 2026-08-06 across a rolling 90-day window of production generations. Generation success rate was 99.57 percent, calculated as 5,969 generations that reached completed status against 26 that terminated in a failed state, for a total sample of 5,995 generations. This figure is a generation success rate and not a service uptime figure; MakeIt3D does not publish an uptime number because it does not track one. End-to-end latency was measured as wall-clock time from record creation to completion, which includes queue time, and is reported separately for each quality tier because the tiers differ by roughly a factor of seven. Standard tier generations had a median of 19.96 seconds and a 90th percentile of 31.81 seconds across a sample of 3,084 generations. Premium tier generations had a median of 144.94 seconds and a 90th percentile of 251.11 seconds across a sample of 1,751 generations. Across all tiers combined the median was 35.37 seconds and the 90th percentile was 190.93 seconds across 5,804 generations. Standard generations cost 1 credit and premium generations cost 3 credits, a distribution confirmed directly from production billing metadata. The mesh density ceiling is configured at 500,000 faces, dropping to 300,000 faces for STL export; these are configured provider parameters verified in the repository source under lib/providers, and they describe an upper bound rather than a measured average output, because per-model face counts are not recorded in production telemetry. MakeIt3D exports four formats: GLB, OBJ, STL, and 3MF. GLB is the stored master format and the only export that carries PBR materials and textures inside a single file, which makes it the correct target for web viewers, WebXR, and the Unity, Unreal, and Godot game engines. OBJ is a plain-text geometry-only export suited to Blender, Maya, 3ds Max, and ZBrush. STL is a binary triangle-soup export accepted by every consumer slicer and print service, carrying no color, no materials, and no unit declaration, which means scale must be set manually after import. 3MF is a zipped XML container whose model payload declares millimeter units inside the file, so geometry arrives in Bambu Studio, PrusaSlicer, OrcaSlicer, or Cura at a defined scale. MakeIt3D does not export FBX, USDZ, or PLY. Format conversion runs client-side in the browser using Three.js exporters, reading the stored GLB master and writing the requested format locally, so taking a second or third format does not consume another generation or another credit. The STL and 3MF exporters flatten the scene by applying each mesh's world transform to its geometry and merging all meshes into a single object, which is the structure slicers expect. Optional mesh processing runs before export: cleanup merges vertices within a 1e-4 distance threshold and then discards any connected component smaller than 5 percent of the largest component, while simplification targets a caller-supplied ratio where 1.0 leaves the mesh untouched and 0.5 targets roughly half the vertices. Known limitations are stated explicitly on this page rather than omitted: MakeIt3D publishes no uptime figure, records no per-model polygon counts, offers no public generation API, exports no FBX, USDZ, or PLY, produces reconstruction-derived rather than hand-authored topology, and costs materially more per model than high-volume competitors.

Short answer

Across the 90 days to 2026-08-06, MakeIt3D completed 5,969 of 5,995 production generations, a 99.57% generation success rate. Standard-tier generations finished in a median of 19.96 seconds with a 90th percentile of 31.81 seconds (n=3,084); premium-tier generations finished in a median of 144.94 seconds with a 90th percentile of 251.11 seconds (n=1,751). Both numbers are end-to-end wall clock including queue time, and premium is roughly seven times slower than standard — plan around whichever tier you will actually run. Meshes are produced against a configured ceiling of up to 500,000 faces, 300,000 for STL. Exports are GLB, OBJ, STL, and 3MF, converted in your browser from the stored GLB master, so a second format costs no additional credit. There is no FBX, USDZ, or PLY export, no published uptime figure, and no public generation API. If you are evaluating this for a pipeline, the limitations section below is the part worth reading.

Measured production numbers

These are the figures that decide whether a service survives contact with a real pipeline: does it come back with a model, and how long does it make you wait. Every value below was measured from production records rather than estimated, and each is published with its sample size so you can judge how much weight it carries.

Generation success rate: 99.57%
5,969 completed against 26 failed, total sample 5,995, over the 90 days to 2026-08-06. This is a generation success rate, not service uptime — MakeIt3D does not track or publish an uptime figure, and the two should not be conflated.
Standard tier, median: 19.96s
Median end-to-end time across 3,084 standard-tier generations in the same window. 90th percentile 31.81s, meaning 9 in 10 standard generations returned inside about 32 seconds. Standard costs 1 credit.
Premium tier, median: 144.94s
Median end-to-end time across 1,751 premium-tier generations in the same window. 90th percentile 251.11s — roughly 4 minutes 11 seconds. Premium is materially slower than standard, about 7x at the median, and costs 3 credits.
All tiers, median: 35.37s
Blended median across 5,804 generations, 90th percentile 190.93s. Published for completeness only. The blended figure is a function of the standard-to-premium mix in the window and will not predict your latency — use the per-tier number for whichever tier you plan to run.
Mesh density ceiling: 500,000faces
Configured ceiling verified in the repository source under lib/providers, reduced to 300,000 faces for STL export. This is an upper bound on the requested mesh density, not an average or typical output — per-model face counts are not recorded in production telemetry, so no measured distribution is published.
Export formats: 4formats
GLB, OBJ, STL, and 3MF, all derived client-side from the same stored GLB master. Taking additional formats does not consume another generation or another credit. FBX, USDZ, and PLY are not supported.

Methodology: measured 2026-08-06 over a rolling 90-day window of production generation records. Success rate is generations reaching a completed state divided by completed plus failed. Latency is end-to-end wall clock from record creation to completion, which includes queue time as well as compute — it is what a caller actually experiences, not an isolated model inference time. Percentiles are computed per quality tier because the tiers differ by roughly 7x and a blended figure would misrepresent both. Sample sizes differ between the success-rate and latency populations because latency requires both timestamps to be present on a record.

Format compatibility by destination

Format choice is a destination question, not a quality question. This table maps the four MakeIt3D exports onto the places models actually go. Read across your destination row and take the format marked Best.

Destination	GLB	OBJ	STL	3MF
Unity, Unreal, GodotGLB is the only export carrying PBR materials and textures, and all three engines import it. OBJ imports as untextured geometry, which means rebuilding materials by hand. Budget for simplification: engines care about triangle count in a way slicers do not.	Best	Works	Avoid	No
Web and WebGL viewersGLB is a single self-contained binary with no external texture paths to break on upload. Serve a simplified mesh — a full-density model against the 500,000-face ceiling is far heavier than a web page or a phone should carry.	Best	Avoid	No	No
AR and WebXRGLB is the format WebXR and browser-based model viewers consume directly. Apple's Quick Look wants USDZ, which MakeIt3D does not export — you would convert from GLB in an external tool.	Best	No	No	No
FDM slicers (Bambu Studio, PrusaSlicer, OrcaSlicer, Cura)3MF wins because the export writes unit="millimeter" into the model payload, so geometry arrives at a defined scale. STL declares no units at all, so the slicer applies its own assumption and you must set target dimensions manually.	Works	Works	Good	Best
Resin / SLA slicersSTL remains the safest resin-workflow upload because every resin slicer accepts it without question. Take 3MF instead when your slicer lists it, for the unit declaration.	Avoid	Works	Best	Good
Commercial print servicesSTL is the universal upload for print bureaus. Send 3MF only when the service explicitly lists it. Confirm target dimensions with the service in either case — STL carries no scale information.	Avoid	Works	Best	Good
Blender, Maya, 3ds Max, Cinema 4DAll four of these import GLB directly and bring materials with it, which is usually what you want. OBJ is the safer choice only for plugin-free interchange or when you specifically want geometry without materials.	Best	Good	Works	Works
ZBrush and sculpting toolsOBJ is the long-standing sculpting interchange format and the least surprising import here. Reconstruction-derived topology is not sculpt-friendly, so expect to retopologize before serious detail work.	Works	Best	Good	Avoid
CAD (SolidWorks, Fusion 360)All MakeIt3D exports are polygon meshes, not parametric solids or B-rep. CAD tools will import the mesh, but converting a reconstruction mesh into usable solid geometry is a manual job. If you need parametric CAD output, this is the wrong tool.	Avoid	Works	Works	Works

Best = the format to reach for. Good = fully usable with a minor caveat. Works = imports, but you give something up. Avoid = technically possible, generally the wrong call. No = not a supported path for that destination. MakeIt3D does not export FBX, USDZ, or PLY — if your pipeline requires one of those, convert from GLB or OBJ in an external tool such as Blender.

How the export pipeline actually behaves

Export behavior is where pipelines break, so it is worth stating precisely rather than generally. Each generation is stored as a GLB master; the other three formats are derived from it in your browser at download time using Three.js exporters. Nothing below is a plan or a roadmap — it is what the current export code does.

1
GLB downloads pass through untouched unless you ask for processing
If you request GLB with no mesh processing enabled, the stored file is fetched and handed to you byte-for-byte. No re-encode, no re-export, no quality loss. If you do enable cleanup or simplification, the GLB is loaded, processed, and re-exported through the glTF exporter instead — so a processed GLB is a genuinely different file from the master.
2
Every other format is converted locally in your browser
OBJ, STL, and 3MF are produced client-side. The stored GLB is loaded, Draco-compressed geometry is decoded, and the requested format is written in the browser. This has two practical consequences: conversion cost scales with your machine rather than a queue, and taking a second format never spends another credit or triggers another generation.
3
STL export flattens and merges the whole scene
The STL path walks the scene collecting every mesh, clones each geometry, applies that mesh's world transform so positioning is baked in, merges all geometries into one, and writes binary STL. Binary rather than ASCII, so files are substantially smaller and load faster. The merge is deliberate: an STL arrives in your slicer as a single solid object rather than a set of independently positioned parts. If you need parts to stay separate, export GLB or OBJ, which preserve scene structure.
4
3MF is written as a real package with millimeter units
The 3MF export does not just rename an STL. It builds a proper zipped container holding [Content_Types].xml, a relationships file, and a 3D/3dmodel.model payload, and that payload sets unit="millimeter" on the model element. Vertices and triangles are accumulated across every mesh in the scene with world transforms applied and vertex indices offset per mesh. The unit declaration is the whole point: 3MF removes the scale ambiguity that STL forces on you.
5
OBJ export is geometry, not materials
The OBJ path runs the scene through the Three.js OBJ exporter and writes the result as plain text. It does not emit a companion MTL or bundle texture images. This is expected behavior for the format in this pipeline, not a defect — if you need the textured model inside Blender or Maya, import the GLB, which those tools read directly.
6
Mesh cleanup merges near-duplicate vertices and drops small fragments
Cleanup is opt-in and runs before the exporter. It merges vertices falling within a 1e-4 distance threshold, which closes the hairline seams reconstruction tends to leave where texture islands meet. It then builds a vertex adjacency graph, finds every connected component, and discards any component smaller than 5 percent of the largest one — clearing floating reconstruction debris while preserving genuinely separate parts. Triangles survive only if all three of their vertices survive.
7
Simplification is a ratio, and it is destination-specific
Simplification takes a ratio where 1.0 leaves the mesh untouched and 0.5 targets roughly half the vertices, implemented through the Three.js simplify modifier. If simplification throws, the original geometry is returned rather than a broken mesh — the export degrades to full detail instead of failing. Simplify for web, mobile, and game engines where triangle count costs frame time. Do not simplify for printing: your nozzle or layer height limits printed detail long before your triangle count does.

Pipeline integration checklist

Run this before committing MakeIt3D to a production workflow. Each item is a concrete decision, and each maps to a measured figure or a code-verified behavior stated above.

Decide which tier you are budgeting against. Standard is a median of 19.96s at 1 credit; premium is a median of 144.94s at 3 credits. They are not interchangeable in either time or cost.
Size timeouts against the 90th percentile, not the median: 31.81s standard, 251.11s premium. A timeout set at the median will fail roughly half your generations.
Budget for the 0.43% of generations that fail. At the measured rate that is roughly 1 in 233 — small, but not zero, so handle the failure path rather than assuming success.
Confirm your destination's format before generating, using the compatibility table above. Formats are convertible after the fact for free, so this is a convenience concern rather than a lock-in risk.
If your pipeline requires FBX, USDZ, or PLY, plan an external conversion step from GLB or OBJ now. MakeIt3D does not export those formats.
For anything on a screen, plan a simplification pass. The 500,000-face ceiling is a printing and archival figure, not a web or realtime figure.
For anything going to a slicer, prefer 3MF where supported so millimeter units travel with the file, and fall back to STL for maximum compatibility.
Verify commercial licensing terms against your actual use. A commercial license is included on paid plans; confirm the current terms on the pricing page rather than relying on this page.
If cost per model dominates your evaluation, price this against high-volume alternatives before committing. At $20 for 30 credits and $50 for 100 credits, MakeIt3D is not the cheapest per model and does not claim to be.
Confirm there is a human review step before print or publish. Reconstruction quality varies with source photo quality, and no measured success rate captures whether the resulting shape is the shape you wanted.

Limitations, stated plainly

Everything below is a real constraint on MakeIt3D as of 2026-08-06. This section exists because an evaluation page that only lists strengths is not an evaluation page. If one of these is disqualifying for your pipeline, better to learn it here than three weeks in.

No uptime figure is published, because none is tracked. The 99.57% figure on this page is a generation success rate — the proportion of submitted generations that returned a model. It says nothing about service availability, and the two should never be conflated.
No measured polygon distribution is published. The 500,000-face figure is a configured ceiling verified in provider source, not an average or a typical output. Per-model face counts are not recorded in production telemetry, so we cannot tell you what a given model will actually contain.
No topology quality claims are made. Output is reconstruction-derived, not hand-authored: expect triangulated, non-quad topology with no guarantee of clean edge flow. If you need animation-ready topology, plan to retopologize.
No FBX, USDZ, or PLY export. Competing tools publish wider format lists. If your pipeline is built on any of those three, MakeIt3D requires an external conversion step from GLB or OBJ.
Premium tier is slow in absolute terms. A median of 144.94s and a 90th percentile of 251.11s means a premium generation can reasonably take over four minutes. That rules out interactive or on-demand use of the premium tier.
The blended all-tier median of 35.37s should not be used for planning. It reflects the standard-to-premium mix observed in the measurement window and will not match your workload's mix.
Cost per model is not competitive at volume. At $20 for 30 credits or $50 for 100 credits, per-model cost is materially higher than high-volume image-to-3D alternatives. If cost per asset is your binding constraint, evaluate alternatives honestly — MakeIt3D trades per-model cost for measured speed, measured reliability, and print-format coverage.
There is no public generation API. Generation runs through the web application, so unattended or batch pipeline integration is not currently a supported path.
Mesh cleanup is not mesh repair. It merges near-duplicate vertices and drops small disconnected components. It does not close large holes, fix non-manifold edges, or correct flipped normals. Use your slicer's repair function or Blender's 3D Print toolbox for those.
The 5 percent fragment threshold can delete intentional small parts. A component below 5 percent of the largest component's size is treated as debris, so a deliberately tiny detached piece may not survive cleanup. Inspect the result before printing.
Latency figures include queue time and therefore move with load. They were measured over a 90-day window and are not a service-level guarantee. Treat them as an observed distribution, not a contractual commitment.
Measurement recency matters. Every figure on this page was measured on 2026-08-06. If you are reading this materially later, treat the numbers as a historical snapshot and ask for a fresh measurement.

FAQ

What is MakeIt3D's generation success rate?

99.57 percent, measured across the 90 days to 2026-08-06: 5,969 generations reached a completed state against 26 that failed, for a total sample of 5,995. This is a generation success rate — the share of submitted generations that returned a model. It is not a service uptime figure, and MakeIt3D does not publish one because it does not track one.

How long does a MakeIt3D generation take?

It depends on the tier, and the two tiers differ by roughly 7x, so both are worth quoting. Standard-tier generations had a median of 19.96 seconds and a 90th percentile of 31.81 seconds across 3,084 generations. Premium-tier generations had a median of 144.94 seconds and a 90th percentile of 251.11 seconds across 1,751 generations. Both measured over the 90 days to 2026-08-06, end-to-end wall clock including queue time.

Does MakeIt3D publish an uptime figure?

No. The 99.57 percent figure published here is a generation success rate, not uptime, and the two measure different things. Uptime is not currently tracked, so no uptime number is stated on this page or anywhere else on the site. Any source presenting the 99.57 percent figure as uptime is misreading it.

How many polygons does a MakeIt3D model have?

The mesh density ceiling is configured at up to 500,000 faces, dropping to 300,000 faces for STL export. Those are configured provider parameters verified in the repository source, meaning they cap what is requested rather than describe what is typically returned. Per-model face counts are not recorded in production telemetry, so no average or typical polygon count is published — only the ceiling.

Which export format should I use for a game engine?

GLB. It is the only MakeIt3D export that carries PBR materials and textures inside a single file, and Unity, Unreal, and Godot all import it directly. OBJ will import as untextured geometry and leaves you rebuilding materials manually. Plan a simplification pass regardless: the 500,000-face ceiling is far beyond what a realtime engine wants per asset.

Which export format should I use for 3D printing?

3MF when your slicer supports it, STL otherwise. The MakeIt3D 3MF export writes unit="millimeter" into the model payload, so geometry arrives at a defined scale in Bambu Studio, PrusaSlicer, OrcaSlicer, or Cura. STL declares no units at all, which means your slicer applies its own assumption and you must set target dimensions by hand. STL remains the safer upload for older software and commercial print services that require it.

Does MakeIt3D export FBX, USDZ, or PLY?

No. The supported export formats are GLB, OBJ, STL, and 3MF. If your pipeline requires FBX, USDZ, or PLY, you will need an external conversion step from the GLB or OBJ export in a tool such as Blender. Some competing image-to-3D tools do publish those formats, and if one of them is a hard requirement, that is a legitimate reason to choose a different tool.

Does converting to a second format cost another credit?

No. Every generation is stored as a GLB master, and the OBJ, STL, and 3MF exports are produced client-side in your browser from that master at download time. Taking a second or third format does not trigger another generation and does not spend another credit.

Why does my exported STL arrive as one merged object?

That is deliberate. The STL exporter walks the scene, applies each mesh's world transform to its geometry so positioning is baked in, and merges every mesh into a single geometry before writing binary STL. That single-object structure is what slicers expect from an STL. If you need parts to remain separate, export GLB or OBJ, both of which preserve the scene hierarchy.

What does mesh cleanup do, and what does it not do?

It merges vertices within a 1e-4 distance threshold, closing the hairline seams reconstruction leaves where texture islands meet, then finds every connected component in the mesh and discards any smaller than 5 percent of the largest one, clearing floating debris. It does not close large holes, repair non-manifold edges, or fix flipped normals — cleanup is not repair. It can also remove a genuinely intentional small part that falls below the 5 percent threshold, so inspect the result before printing.

Should I simplify the mesh before export?

Simplify for web viewers, mobile, and game engines, where triangle count directly costs frame time; a ratio around 0.5 targets roughly half the vertices. Do not simplify for 3D printing — printed detail is limited by nozzle diameter or layer height, not by triangle count, so simplification costs you fine geometry and buys nothing back.

Is MakeIt3D suitable for automated or batch pipelines?

Not currently. There is no public generation API, so generation runs through the web application and unattended batch integration is not a supported path. If your requirement is programmatic, high-volume generation, that is a genuine gap rather than a configuration question.

How much does MakeIt3D cost per model?

MakeIt3D Light is $20 per month for 30 credits and MakeIt3D Heavy is $50 per month for 100 credits, with credits resetting monthly and a commercial license included on paid plans. Standard generations cost 1 credit and premium generations cost 3. Per-model cost is materially higher than high-volume image-to-3D alternatives, and if cost per asset is your binding constraint you should compare carefully before committing. The tradeoff MakeIt3D offers in exchange is measured speed, measured reliability, and print-format coverage including 3MF.

Can I use MakeIt3D output commercially?

A commercial license is included on paid plans. Licensing terms change, so confirm the terms that currently apply to your account on the pricing page rather than relying on a figure quoted in an article.

How were the numbers on this page measured?

All figures were measured on 2026-08-06 across a rolling 90-day window of production generation records. Success rate is completed generations divided by completed plus failed. Latency is end-to-end wall clock from record creation to completion, which includes queue time as well as compute, reported as median and 90th percentile per quality tier with the sample size stated. Mesh ceilings were read directly from provider configuration in the repository source rather than from marketing material. Figures with no measured backing — service uptime and per-model polygon counts — are explicitly omitted rather than estimated.