How to verify a STEP to STL conversion
Every number below was measured on the machine that wrote this page, and all of them are re-checked by npm test. Nothing here is an estimate or a rule of thumb.
Six checks, in the order they are worth doing. A conversion can look finished and still be wrong, because “it produced an STL” is not the same claim as “the STL matches the model”. The checks below separate those two claims. Each one uses a number you can compute yourself from the file you already have — no reference model, no CAD licence, no second tool.
- Recover the triangle count from the file size. A binary STL stores each triangle in a fixed 50 bytes behind an 84-byte header. Take the byte count, subtract the 84-byte header, then divide what is left by 50 — that is the triangle count the converter must have produced. The order matters: dividing first and subtracting afterwards gives you a negative number, not a triangle count.
- Count the edges to prove the mesh is closed. A watertight mesh has every edge shared by exactly two triangles. One edge used once is a hole.
- Compare the bounding box against the size you know. A wrong number here is almost always a unit mismatch, and it announces itself as a factor of 25.4. The units page works through the cases.
- Sanity-check the triangle count against curvature. Flat faces always cost 12 triangles on a cube. If a curved part produced very few, the preset that ran was coarser than you expected.
- Confirm the reader that ran matched your format. A STEP file and an IGES file take different code paths and can land on different results for the same solid.
- On an analytic test piece, measure how far the mesh bends. Where the surface is known from the file's own text, the mesh's maximum stray from it is computable — and it shrinks tier by tier.
The file size tells you the triangle count
This is the most useful check and the cheapest, because it needs nothing but the file size and a calculator. The binary STL layout is fixed: an 80-byte header, a 4-byte triangle count, then 50 bytes per triangle, so the whole file size is determined by the triangle count alone.
| Identity | bytes = 84 + 50 × triangles |
|---|---|
| Inverted | triangles = (bytes − 84) ÷ 50 |
| Worked example | A 10 mm cube converts to 12 triangles: 84 + 50 × 12 = 684 bytes. Our IGES cube of the same solid also comes to 684 bytes, from the same 12 triangles. |
| Why it is trustworthy | The engine vendor ships a reference cube-10x10.stl alongside the cube-10x10.stp it converts from. Our run of that STEP file produces 12 triangles, and the vendor’s own reference file is 684 bytes on disk. Two independent artefacts, one identity. |
The practical consequence is worth stating plainly: a larger STL is not a better conversion. File size carries no quality information beyond triangle count. If you get two files of the same part and one is bigger, it has more triangles, which usually means a finer preset ran — not that the conversion was more correct. And because the identity is exact, it doubles as an integrity check. If your file is 684 bytes but the converter reported 6,088 triangles, the download was truncated. There is no rounding in this formula, so any mismatch is a real fault.
The measurement only works on binary STL, which is why that is the default here. An ASCII STL is a text file with no fixed record size, so the identity does not apply to it — see check 3’s neighbour below for what ASCII costs.
Binary STL only (84 + 50 × triangles). ASCII STL does not follow this identity. The arithmetic runs in this tab — nothing is sent anywhere.
Count the edges to prove the mesh is closed
A solid model that a slicer can work with has no boundary: every triangle edge is shared with exactly one other triangle. That gives you a number you can check without rendering anything. Our IGES test cube — a solid, so it should close — measures 18 edges across its 12 triangles, every one of them used exactly twice, forming one connected piece. The arithmetic is worth doing once, because it tells you what to expect from any closed solid: 12 triangles carry 12 × 3 = 36 edge-uses, and since a closed mesh uses each edge exactly twice, that is 36 ÷ 2 = 18 distinct edges. Twelve triangles is the floor here — a cube has 6 faces of 2 triangles each, and no closed solid can be built from fewer.
What the check catches: a count where some edges are used once means the shell is open, and an open shell is not printable because the slicer cannot tell inside from outside. That failure is almost never introduced by the conversion. It arrives in the source file as a gap or a self-intersection and leaves as the same gap, because this page triangulates and does not repair. The count is how you tell which it was.
Compare the bounding box against the size you know
Converters report the bounding box — the smallest box containing the part — and that number is worth checking against reality, because a scale error that is almost right is hard to notice and a unit error is easy to recognise. The tell is that unit errors are not approximate. They are a clean factor of 25.4, because that is the number of millimetres in an inch.
If your slicer shows the part at 1/25.4 or 25.4 times the reported box, the file was interpreted in the wrong unit. The conversion is fine; the reading of it is not. Any other ratio — a part that is simply the wrong size — is a modelling question, not a conversion question.
| Units here | Everything is measured in millimetres, the engine default. The unit declared inside your STEP file is applied before you see a number. |
|---|---|
| Proof pair | Two identical cubes, one declaring UNIT('INCH') with coordinates written as multiples of 39.370078740157 (= 1000 ÷ 25.4), one declaring millimetres with coordinates of 1000. Both measure 1000 × 1000 × 1000 mm after the declared unit is applied. Same solid, same result, opposite declarations. |
| Larger assemblies | The 18-part AP203 model measures 5080 × 2209.8 × 3810 mm; the AP214 model measures 200 × 150 × 84 mm. Both files declare millimetres and neither is re-scaled on the way out. |
| Orientation | Nothing is rotated, aligned, centred or scaled. Coordinates land in the STL in the system the model already used. Flat-bottom orientation is your slicer’s job. |
The same real part, declared four ways. A unit declaration is not a header comment that gets skipped. One DN80 PN16 flange (EN 1092-1, outside diameter 200 mm, 20 mm thick) exists four times in the test set, its coordinates written in millimetres, centimetres, metres and inches. All four measure 200 × 199.94 × 20 mm once the declared unit is applied — 199.94 rather than 200 because that axis is measured across the tessellated rim, and the tessellation stops just short of the surface. Draft reads 200 × 198.54 × 20 and Normal 200 × 199.44 × 20 on the same file, so the small shortfall tracks the preset and not the units. Ignore the declaration and the centimetre copy would read 20 mm and the inch copy 7.87 mm — a clean factor of 10 or 25.4, which is exactly the mismatch this check is built to catch.
Read the triangle count against curvature
Triangle count is driven by how much curved surface the part has, and by how finely you asked for it to be sampled. Flat faces cost nothing extra, which is why the presets are invisible on a cube and obvious on a cone. These are measured counts, one part per row, all three presets:
| Test file | Shape | Draft tri | Normal tri | Fine tri | Fine ÷ Draft |
|---|---|---|---|---|---|
| simple-cube.stp | Flat cube | 12 | 12 | 12 | 1.0× |
| cube-10x10.stp | Flat cube | 12 | 12 | 12 | 1.0× |
| cube-10x10.igs (IGES) | Flat cube | 12 | 12 | 12 | 1.0× |
| rounded-cube.step | Rounded edges | 40 | 56 | 140 | 3.5× |
| conical-surface.step | Curved surface | 286 | 516 | 2,142 | 7.5× |
| as1_pe_203.stp (18 parts) | Assembly | 3,848 | 6,088 | 17,848 | 4.6× |
| as1-oc-214.stp (18 parts) | Assembly | 4,900 | 7,372 | 21,116 | 4.3× |
Two things to take from that table. A flat part cannot identify the preset — every cube reads 12 across all three, so if you were expecting the quality control to change a cube, nothing broke. And the presets diverge fastest on the hardest geometry: going from Draft to Fine multiplies the cone by 7.5 and the rounded cube by 3.5, while leaving the flat cubes untouched. If you want to know which preset actually ran, convert a curved part.
One question keeps arriving phrased with a quantity and answered with an adjective: how accurate is a STEP to STL conversion? An answer that only states an intention — the tool aims for the most accurate result it can — gives the reader nothing to check and nothing to reproduce. A checkable answer names numbers that move with the setting: how far the surface may deviate, how many triangles came out, and how many bytes the file holds. All three are printed on this page — the deviation is measured on the cone in the chordal section below, the counts are in the table above, and the byte figure is 84 + 50 × triangles — and npm test re-derives each of them on every run. An accuracy claim that carries none of the three is a sentence about intentions rather than about a file.
This is also where the quality choice stops being a preference. Normal is right for printing. Draft is for checking fit and orientation on an assembly you only need to eyeball. Fine is for a fillet or a cylindrical face that looks faceted in the preview. The preset values themselves are this site’s own choices, not a CAD standard: Draft 0.02 bounding-box ratio and 0.5 angular, Normal 0.005 and 0.3, Fine 0.001 and 0.1, with npm test diffing them against the shipped worker’s values.
The unit fix lands before sampling, so it must not move the triangle count either. Those four declarations of the same flange return 1,072 / 1,712 / 5,072 triangles at Draft / Normal / Fine — identical across all four files, because the coordinates are converted to millimetres first and only then handed to the tessellator. A converter that rescaled the finished mesh instead would show the same bounding box and a different count, which is why the two numbers are worth reading together.
Confirm which reader ran, and what it will not read
STEP and IGES are different formats with different internal structures, and this page dispatches to a different reader for each. The dispatch is by extension: .step and .stp go to the STEP reader, .iges and .igs to the IGES reader. For our test cube the two paths land on the same counts — 12 triangles, 18 edges each shared twice, one piece, 684 bytes — which is a useful baseline, but it is a property of this particular solid rather than a general guarantee.
Measured byte by byte, that agreement has an edge, and it is worth knowing before you diff two STLs. The two source files are different sizes: cube-10x10.stp is 9,138 bytes, cube-10x10.igs is 11,421, a gap of 2,283 bytes, because each format writes its own records. Both come out as a 684-byte binary STL of 12 triangles, 18 edges each shared twice, one piece, a 10 × 10 × 10 mm box, and a closed mesh whose computed volume is 1,000 mm³. Compare the two 684-byte files byte for byte and 9 of those 684 bytes differ (1.3%), the first of them at offset 487. All nine sit inside three triangle records, and all nine are sign bits: two triangles of the flat y = 0 face are split along the opposite diagonal, one triangle of the y = 10 face lists the same three corners starting from a different one, so eight bytes flip the sign of a ±5 coordinate and one writes a zero normal component as −0.0 instead of +0.0. Same solid, same count, same size — not the same file. That is why check 1 counts triangles instead of diffing bytes: a byte comparison between a STEP-sourced and an IGES-sourced STL reports a difference on a part where nothing is wrong. To see it yourself, fc /b on Windows or cmp -l elsewhere prints exactly those nine offsets, and both files still satisfy 84 + 50 × 12 = 684.
There is a difference worth knowing about that is specific to IGES: it stores surfaces rather than a solid. This page writes every mesh it receives into one STL without stitching surfaces together, so surfaces that do not actually meet in the file stay separate pieces in the output. A multi-piece result from an IGES source is not necessarily a fault in the source — inspect it.
The formats this converter does not accept are worth stating plainly, because many converters that advertise STEP-to-STL also advertise a much longer list. It reads STEP and IGES only. It does not read OBJ, PLY, GLB, FBX, DWG or OFF, and it cannot be made to without replacing the engine. 3MF is a separate case in both directions, not a claim of support: 3MF is read by a standalone JavaScript reader on its own page, and an STL is written back out as 3MF by a package writer on its own page. Neither touches this engine, and neither adds a format to this converter. Those two pages are the whole 3MF footprint and the cap: one reads a 3MF, one writes a 3MF, and the main line of this site remains STEP↔STL.
- The measurement has a control group. A negative result means nothing unless the same harness can produce a positive one, so the probe always converts a known-good STEP file first:
cube-10x10.stpcomes back as 1 mesh and 12 triangles through the same dispatch. It refuses to report any unsupported verdict unless that control passed. - The reason is the engine, not the website. The shipped build exports four readers — STEP, IGES, BREP and a generic fallback — and no OBJ, GLB, FBX or DWG importer is linked into the WebAssembly binary at all. Adding them means recompiling with those importers, which is a different engine rather than a setting.
- The generic fallback is not a format detector. A control worth knowing: the engine’s own output, the
cube-10x10-reference.stl, does not read back in. So the fallback reader will not rescue an unexpected extension; it is scoped to what it was built for. - This is an inference, not a formal proof. The reasoning chain: the engine exports four readers and no importers for those formats, and probes for each of them returned nothing usable while the control succeeded. The fixtures are minimum-size structurally valid files constructed in memory, not complete production files. To hold “a full, real DWG is also unsupported” as hard evidence, a real sample would have to be converted as well.
A missing CAD package is a different situation from an unsupported extension: the reader itself runs in the browser, no seat required — opening a STEP file without CAD is measured on its own page.
One question belongs here rather than on a page of its own, because it comes up whenever a converter reprints a STEP header as proof: is a real header evidence that the tool can read the format? It is not, and our own samples make the reason measurable. A header is text inside the file, so it is evidence of what the file declares about itself — not of anything the reader did. The label is unreliable too: as1_pe_203.stp declares an 82-character schema name, AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF, wrapped so that the statement runs 101 bytes over two lines, the break falling 13 bytes in; as1-oc-214.stp declares 43 characters, AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }, on a single 61-byte line — and that line contains the string AP214 nowhere, so searching a genuine AP214 header for the flavour’s own name comes back empty. What a reader is worth shows up only in its output, which is what the checks on this page measure: the same cube in, one piece and 12 triangles out, 684 bytes, 18 edges each used twice. Both statements are quoted byte for byte, break included, on the flavours page.
AP214. Neither header proves that anything can read it. The counts on the right are what a reader produced from those same files.The one format choice that changes the numbers: ASCII
If you need a text STL, know what it costs before you pick it. Same geometry, same triangles, more bytes — across all 27 sample-and-quality combinations we measured, ASCII runs 3.3 to 4.0 times the binary size (exact spread 3.276–4.030). The 18-part assembly at Normal is 304,484 bytes binary against 1,226,556 ASCII for the same 6,088 triangles. The flat cube is the cheapest case at 3.28× and the assembly the dearest at 4.03×, because ASCII pays a fixed per-triangle text cost that a large triangle count amplifies.
Choose it when a tool explicitly asks for a text STL you can open in an editor. Otherwise binary — it is what slicers expect, and it is the format the size identity in check 1 applies to.
Measure how far the mesh bends from the true surface
Checks 1 through 5 treat the mesh as nothing but triangles. The sixth asks the accuracy question behind them: how far do those triangles stray from the exact surface the STEP file declares? For an arbitrary file the honest answer is the deflection pair — the two numbers the converter requests from the kernel are an upper bound on the error, not a measurement of it. But when the surface is analytically known, the stray becomes measurable, and the surface is known here because a STEP file is text: this site's cone sample carries its CONICAL_SURFACE parameters in plain view — a π/4 semi-angle, a reference radius and an axis, all readable from the file itself.
Sampling the interior of every cone-face triangle on a fine lattice and taking the closed-form point-to-cone distance gives a measured chordal deviation of 0.174179 mm at Draft, 0.057284 mm at Normal and 0.009414 mm at Fine — each under the deflection the preset requested, each roughly a third of the tier before it. The same measurement identifies which triangles actually lie on the cone: 43 at Draft, 128 at Normal, 670 at Fine. The boundary of this claim is as important as the number: it holds for test pieces whose surfaces the file text declares analytically, and it is never computed for arbitrary user files — for those, the converter's audit panel reports the mesh's own volume and surface area, labelled as mesh approximations.
The same absolute-deflection sweep is recorded for four curved IGES parts, at 0.5, 0.1, 0.05 and 0.01 mm of linear deflection with a 0.3 rad angular limit. Each row is the triangle count this engine returns, and the test re-measures all sixteen cells against the recorded reference:
- DN80 flange — 1,724 / 2,044 / 2,348 / 5,172
- NURBS sphere, 80 mm across — 2,480 / 9,192 / 18,588 / 111,364
- NURBS blade loft — 481 / 2,447 / 4,502 / 26,978
- Filleted 80 × 60 × 30 mm block — 360 / 360 / 372 / 784
Read the other way, the presets stop being abstract ratios. On the sphere the Normal preset returns a triangle count that falls between 0.33 and 0.35 mm of linear deflection; on the filleted block the same preset falls between 0.05 and 0.06 mm. The difference is the point: the preset is a fraction of the part, not a fixed distance from the surface, so a figure quoted in millimetres only means something once it names the part it was measured on. All four boxes above are measured from the triangles rather than from the parsed surface data — on the blade, the B-spline control points sit outside the surface and would report a part wider than it is.
One tier step, three numbers that move differently
Check 6 measures a distance, check 1 counts bytes and check 4 counts triangles — and on the same conical test part, at the same three presets, the three move by three different multipliers. The table below gathers one run into one place so the quantities can be read against each other instead of one at a time.
| Draft | 0.174179 mm deviation | 43 cone-face triangles | 286 triangles | 14,384 bytes |
|---|---|---|---|---|
| Normal | 0.057284 mm deviation | 128 cone-face triangles | 516 triangles | 25,884 bytes |
| Fine | 0.009414 mm deviation | 670 cone-face triangles | 2,142 triangles | 107,184 bytes |
| Draft → Fine | 18.5× finer | 15.6× more | 7.5× more | 7.45× more |
Read the ratio row before the tiers. Bytes and the total triangle count cannot disagree, because every triangle costs exactly 50 bytes: 84 + 50 × 2,142 = 107,184. Those two are one fact written twice, so neither can say anything about accuracy beyond “more triangles”. The deviation falls 18.5× between the same two presets while the file grows 7.45× — the accuracy bought is about 2.5 times the size bought.
The cone-face count explains the difference. Only the triangles that lie on the curved surface are resampled finer; the flat cap and base keep their own triangles, so they dilute the ratio. Between Draft and Fine the cone-face count grows 15.6× against 7.5× for the whole mesh — the same improvement, measured on the part of the mesh that can carry it. Which quantity saturates first is therefore not a matter of taste: the total count is the first of the three to stop being a fair proxy for accuracy, and the deviation is the last.
The steps are not the same size either. Draft to Normal buys 3.04× less deviation for 1.80× the triangles; Normal to Fine buys 6.08× for 4.15×. Neither step is wasted, but on this part the second is the better purchase per triangle — and on a flat cube all three presets buy nothing, because the count never leaves 12.
Does a finer preset improve accuracy faster than it increases the file size? Yes, on the conical test part. Draft to Fine multiplies the file by 7.45 and the triangle count by 7.5, while the measured chordal deviation falls from 0.174179 mm to 0.009414 mm, 18.5 times finer. Count the triangles that actually sit on the curved face instead of the whole mesh and the gap narrows: 43 to 670 is 15.6 times. The count understates the accuracy gain because flat faces never subdivide; the deviation is the quantity that keeps improving per byte.
The measurement behind the first column, and the boundary of that claim, are argued in check 6 above; the byte ledger for three shapes side by side is on the triangle-count page; and which of these numbers belongs to the format, to this site’s sampling rule, or to a service’s upload cap is split on the resolution-label page.
The whole thing on one screen
| Byte size | 84 + 50 × triangles. Recovers the triangle count, and a mismatch against the reported count means a truncated download. |
|---|---|
| Edge count | Every edge used exactly twice means a closed shell. Used once means a hole, and it came from the source file. |
| Bounding box | Off by exactly 25.4× means a unit mismatch, not a bad conversion. Everything here is millimetres. |
| Triangle count | Driven by curvature and preset, never by file size. Flat cubes read 12 at every setting. |
| Reader path | STEP and IGES take different readers and can differ. Only STEP and IGES are read at all. |
| Chordal deviation | On the analytic test cone: 0.174179 / 0.057284 / 0.009414 mm at Draft / Normal / Fine, each under the requested deflection. Measured against the surface the file itself declares; never computed for arbitrary files. |
If a conversion passes all six, the mesh matches the model it came from as closely as a triangle format allows. It does not mean the model itself was sound — a bad part converts to a faithfully bad STL. Fix that in the CAD tool that made it.
When the conversion never starts — NURBS surfaces and plane-only tools
If the converter reports that your STEP cannot be read at all, the most common cause is not a broken file. It is that your file contains NURBS surfaces — the mathematically precise curved faces that most CAD tools write into STEP by default — and the tool you chose only reads STL-style planar or faceted STEP. Tools that advertise “STEP to STL” can still silently skip anything that is not already a triangle mesh. The vendor of one such tool even publishes this limitation in its own FAQ.
The self-test: convert a part you know has a curved face — a cone or a rounded corner is enough — at both the coarsest and finest preset. If the triangle count stays the same across presets, the tool is not subdividing geometry. It is just passing through whatever mesh was already in the file. The tool on this page produces 286, 516, and 2,142 triangles for the same cone at its three presets — a 7.5 × spread from coarsest to finest. No file of triangles can grow or shrink by that much; only a true CAD kernel tessellating a curved surface can.
This is not a claim about this converter. It is the one check you can run on any converter to find out whether it reads STEP as STEP or as a triangular mesh.
Where these numbers come from
Published · Last updated
- Every triangle count, byte size, edge count and bounding box — produced by running the shipped engine version (occt-import-js 0.0.23, a WebAssembly build of OpenCASCADE) in Node.js over the project’s own test files on this machine.
npm testre-runs all of them, diffs each figure, and re-checks the 12-triangle cube end-to-end in a headless browser. - 84 + 50 × triangles — the published binary STL record layout, cross-checked against the reference STL shipped with the engine vendor’s own test set.
- 25.4, and the inch/mm proof pair — 25.4 is the exact number of millimetres in an inch. The pair is two geometrically identical cubes, one declaring
UNIT('INCH')and one declaring millimetres;npm testasserts both bounding boxes and the inch declaration. - The 2,283-byte input gap and the 9 differing bytes — measured by writing both cubes through the same binary-STL writer this page uses at Draft, Normal and Fine, then comparing the two 684-byte outputs byte by byte;
npm testre-runs the comparison and asserts the two source sizes, the differing byte count, the first offset, the unchanged volume and the unchanged bounding box. - The two schema statements and their byte counts — extracted from the project’s own samples
as1_pe_203.stpandas1-oc-214.stpwith a byte-level read;npm testre-extracts both statements and re-checks 101 / 61 bytes, the 2 / 1 line split, the 13-byte break and the 82 / 43-character names, including that the AP214 statement never contains the stringAP214. - The 3.3–4.0× ASCII range and the 27-combination count — measured by writing both formats through the same shipped STL writers the page uses, once per sample per preset.
- The unsupported-format list — from
node tests/format-support.js, which probes each format against the same reader dispatch with a known-good STEP control. Labelled as inference above, with the reasoning chain given.
The converter on the front page reports the bounding box, triangle count and solid-part count for your own file after every run, so you can apply checks 1, 3 and 4 without leaving the tab. Its about page states who runs it and what it will not do. Every byte and triangle count quoted on this page belongs to the measured table on the front page, re-run by npm test. The six steps these checks are checking, in the order the converter runs them, are on the workflow page.
Sponsored link: Creality’s official store (3D printers, scanners, filament and parts) is an affiliate partner — clicking it may earn this site a commission. It changes nothing about the converter; see what sponsored links mean here.