STEPโ†’STL Your file stays in this tab ยท nothing is uploaded

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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 six checks in order, each one a number you can compute from the file alone Six numbered boxes left to right. One, file size, gives the triangle count. Two, edge count, says whether the shell is closed. Three, bounding box, catches a unit error as a factor of twenty-five point four. Four, triangle count against curvature, says which preset ran. Five, reader path, says whether STEP or IGES was read. Six, chordal deviation, measures how far the mesh strays from the true surface on an analytic test cone. Each box needs only the file you already have, no reference model and no second tool. Six checks, cheapest first, none of them needing a reference model each one is a number you can work out from the file alone 1 File size → triangles 2 Edge count → closed? 3 Bounding box → unit error? 4 Triangles → which preset 5 Reader path → STEP or IGES 6 Chordal dev → mesh stray Checks 1 to 3 need nothing but the output file. Check 4 needs the part in front of you. Check 5 inspects the reading path; check 6 measures against the cone's own text.
The six checks are a ladder, not a checklist. Each rung answers a question the previous one raises, and each is computed from the file you were handed. Check 1 turns a byte count into a triangle count, which is the number every later check compares against. Check 2 turns an edge count into a yes-or-no answer about whether the mesh is watertight. Check 3 turns a bounding box into a units verdict. Check 4 turns the triangle count into a statement about the preset. Check 5 is the only one that inspects the reading path. Check 6 turns a known surface into a measured distance between it and the mesh. Nothing here needs a reference model, a CAD licence or a second tool.

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.

The binary STL size identity
Identitybytes = 84 + 50 × triangles
Invertedtriangles = (bytes − 84) ÷ 50
Worked exampleA 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 trustworthyThe 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.

An STL file built as an 84-byte header plus 50 bytes per triangle A 10 millimetre cube converts to 12 triangles. The file is one 84-byte block followed by twelve 50-byte triangle blocks, which adds up to exactly 684 bytes. Subtracting 84 from any binary STL and dividing the remainder by 50 recovers its triangle count. A 12-triangle STL is 84 + 50 × 12 = 684 bytes 84-byte header 50 B 50 B 50 B 50 B 50 B 50 B 12 triangle records × 50 bytes 684 B total (684 − 84) ÷ 50 = 12 triangles — the count is recoverable from the size alone
Why the file size is the first check. The binary STL layout is fixed: an 80-byte header, a 4-byte triangle count, then 50 bytes per triangle. There is no padding and no compression, so file size and triangle count are the same fact written two ways. The orange block is the header; each teal block is one triangle. Count the blocks or do the division on a file you already have — either way you get the number the converter claims, and if the two disagree the download was truncated.

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.

A closed shell where every edge is shared by two triangles, beside an open shell with four edges used once On the left a cube drawn as 12 triangles, its 18 edges each used exactly twice, so it is a closed shell. On the right the same cube measured with one whole square face removed, leaving 10 triangles, 17 distinct edges and 4 edges used only once, which is a hole and the mesh cannot be printed. Every edge used twice = closed. Used once = a hole. Closed shell 12 triangles, 18 edges each used exactly 2× 36 edge-uses ÷ 2 = 18 Open shell 10 triangles, 17 edges 4 edges used once a slicer cannot tell inside from outside, so it will not print
Why the edge count finds the hole. Two drawings of the same cube, both measured by the test suite. On the left every edge is shared by exactly two triangles, so the mesh has no boundary and the slicer has an inside to work out. On the right one square face is gone: 12 triangles become 10, the 18 distinct edges become 17, and the four edges that framed the missing face are now used only once. Those four single-use edges are the whole diagnosis. The arithmetic behind the closed case is worth doing once — 12 triangles carry 36 edge-uses, and a closed mesh spends each edge twice, so 18 edges is the number any closed 12-triangle solid must produce.

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.

Bounding boxes measured from the test files
Units hereEverything is measured in millimetres, the engine default. The unit declared inside your STEP file is applied before you see a number.
Proof pairTwo 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 assembliesThe 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.
OrientationNothing 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:

Triangle counts measured with this engine in Node.js on this machine; npm test re-runs every cell and fails on a mismatch.
Test fileShapeDraft triNormal triFine triFine ÷ Draft
simple-cube.stpFlat cube1212121.0×
cube-10x10.stpFlat cube1212121.0×
cube-10x10.igs (IGES)Flat cube1212121.0×
rounded-cube.stepRounded edges40561403.5×
conical-surface.stepCurved surface2865162,1427.5×
as1_pe_203.stp (18 parts)Assembly3,8486,08817,8484.6×
as1-oc-214.stp (18 parts)Assembly4,9007,37221,1164.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.

One adjective, six numbers: the same cone at three presets Three columns for the conical test part at Draft, Normal and Fine. Draft is 286 triangles and 14,384 bytes, Normal is 516 triangles and 25,884 bytes, Fine is 2,142 triangles and 107,184 bytes. Fine carries 7.5 times the triangle count of Draft, while a flat cube reads 12 at all three. An answer that only says the conversion is accurate names none of these six figures. One adjective, six numbers Same conical test part, three presets. Every figure below is re-run by npm test. Draft 286 triangles 14,384 bytes Normal 516 triangles 25,884 bytes Fine 2,142 triangles 107,184 bytes Fine is 7.5× Draft on this part; on a flat cube all three presets read 12.
Six values, one part. An accuracy sentence that names none of them describes an intention; these three pairs are what a reader can re-measure.

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.

Where the nine bytes sit in two 684-byte STL files Three of the twelve triangle records differ between the STEP-sourced and the IGES-sourced STL. The y = 0 face is split on opposite diagonals in the two files, the y = 10 face lists the same three corners starting from a different one, and one normal component is written as minus zero. Together these change 8 sign bytes plus 1 zero-normal byte: 9 of 684 bytes, 1.3 percent, first at offset 487. The other 675 bytes are identical. 9 of 684 bytes differ — three of the twelve records y = 0 face STEP splits this face on one diagonal, IGES on the other — 8 sign bits flip y = 10 face Same three corners, listed from a different one — inside those same eight bytes one normal component −0.0 instead of +0.0 the ninth byte first difference offset 487 675 bytes stay identical
Same solid, same 12 triangles, same 684 bytes — and still not the same file. Three records differ by 9 bytes: two faces cut on opposite diagonals, one triangle starting from a different corner, one zero written as −0.0. That is why the first check counts triangles instead of diffing bytes.

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.

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.

A header is the file's own claim, beside the counts a reader actually produced Left panel: two headers measured from this site's sample files. The AP203 sample's schema statement is 101 bytes over two lines with an 82-character name; the AP214 sample's is 61 bytes on one line with a 43-character name and does not contain the string AP214 at all. Right panel: what the same run produced, one piece, 12 triangles, 684 bytes, and 18 edges each used twice. The header belongs to the file; only the counts belong to the reader. The header belongs to the file — the counts belong to the run Header written in the file AP203 sample — 101 B, 2 lines schema name 82 characters AP214 sample — 61 B, 1 line schema name 43 characters search it for “AP214” → no match Counts out of the run 1 piece 12 triangles, 684 bytes 18 edges, each used twice the same solid that wrote the header on the left A header proves what the file declares. Only the counts prove what the reader did.
Two real headers, measured byte for byte: 101 bytes over two lines for the AP203 sample, 61 bytes on one line for the AP214 sample — whose text never contains the string 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:

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.

Three quantities measured on the same cone at each preset, with the Draft to Fine ratio of each
Draft0.174179 mm deviation43 cone-face triangles286 triangles14,384 bytes
Normal0.057284 mm deviation128 cone-face triangles516 triangles25,884 bytes
Fine0.009414 mm deviation670 cone-face triangles2,142 triangles107,184 bytes
Draft → Fine18.5× finer15.6× more7.5× more7.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.

Four multipliers from one preset change Draft to Fine on the conical test part, one bar per quantity. The measured deviation falls 18.5 times, the cone-face triangle count grows 15.6 times, the whole-mesh triangle count grows 7.5 times and the STL byte count grows 7.45 times. Only the first bar is a reduction; the other three are growth, and the whole-mesh bar is shorter than the cone-face bar because flat faces never subdivide. Four multipliers, one preset change Draft to Fine on the cone: one bar falls, three grow. Measured deviation 18.5× finer Cone-face triangles 15.6× Whole-mesh triangles 7.5× STL bytes 7.45× Draft → Fine, all four measured on the same run
Read the bars as ratios, not as sizes: the deviation falls while the other three grow, so the longest bar is the only one where the smaller number is the better result. The whole-mesh bar sits below the cone-face bar because flat faces never subdivide — the count dilutes the accuracy gain, the deviation does not.

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

The six checks and what each one catches
Byte size84 + 50 × triangles. Recovers the triangle count, and a mismatch against the reported count means a truncated download.
Edge countEvery edge used exactly twice means a closed shell. Used once means a hole, and it came from the source file.
Bounding boxOff by exactly 25.4× means a unit mismatch, not a bad conversion. Everything here is millimetres.
Triangle countDriven by curvature and preset, never by file size. Flat cubes read 12 at every setting.
Reader pathSTEP and IGES take different readers and can differ. Only STEP and IGES are read at all.
Chordal deviationOn 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.

Three preset counts for one cone Three vertical bars showing the triangle count of the same conical-surface.step file at Draft (286), Normal (516), and Fine (2,142) presets. Draft is the shortest, Normal sits about one quarter up, Fine reaches the top. Draft 286 Normal 516 Fine 2,142 7.5× Draft→Fine
If the bars never change height across presets — say all three read 286 — the tool is not subdividing geometry, it is just relaying a mesh that was already there.

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

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.