# CutOptim

> CutOptim is a browser-based cutting optimization tool for woodworkers, metalworkers, glaziers, and fabricators. It minimizes material waste using bin-packing algorithms for 2D panels (plywood, MDF, glass, metal sheet), 1D linear stock (rods, pipes, bars), and wood/timber cross-sections.

## Product

- [App](https://cutoptim.com/app): The optimization application (2 free runs without an account, then 3 a month with a free account; no install required)
- [Pricing](https://cutoptim.com/pricing): Free, Pro ($9.99/mo), Workshop ($29/mo, called Business until 2026-07-27) plans, plus one-time pay-as-you-go credit packs (no subscription)
- [About](https://cutoptim.com/about): About CutOptim and its founder
- [Benchmarks](https://cutoptim.com/benchmarks): Open measurement against a theoretical lower bound on published academic bin-packing instances (Berkey & Wang / Martello & Vigo CLASS, Bengtsson BENG, Macedo et al. A). For every test job the minimum number of sheets any plan could use is computed, and the CutOptim result is reported against it, job by job. Raw data downloadable as JSONL and published under CC BY 4.0 (CutOptim's own measurement output and generated corpus only — the academic instances are hash-pinned and fetched, never redistributed); the run is reproducible from the repository. CutOptim does NOT publish a "typical yield" percentage — how much of a sheet gets used depends on the piece mix, stock sizes and kerf, and this page reports the measurement instead of a promise.

## Documentation (English)

- [Getting Started](https://cutoptim.com/docs/getting-started): First optimization walkthrough, plan comparison, key capabilities
- [Pay-as-you-go Credits](https://cutoptim.com/docs/pay-as-you-go): One-time credit packs (10 or 25 optimizations, 12-month validity) instead of a subscription — credits simply buy extra runs after the monthly free quota is used up (every feature is already free on every plan); a CutOptim-only option
- [Interface Overview](https://cutoptim.com/docs/interface-overview): Input panel, canvas, toolbar, results panel explained
- [2D Panel Cutting](https://cutoptim.com/docs/2d-panel-cutting): Sheet material optimization, guillotine vs nested, stock priority, edge banding, sawn cut length and cut count
- [1D Linear Cutting](https://cutoptim.com/docs/1d-linear-cutting): Bar/rod/pipe length optimization
- [Wood Cutting Mode](https://cutoptim.com/docs/wood-cutting): Timber and structural lumber with cross-section grouping; a Roof framing template row opens the rafter length calculator, whose gable/shed roof cut list (rafters, ridge, collars, counter battens, tile battens) comes back into Wood cutting mode
- [Surface Mode (Pavers)](https://cutoptim.com/docs/surface-mode): Paver layout in the app — area by size, side list or drawing, numbered cut pieces, which paver each piece comes from, half stones, kerb stones, order list, PDF with preview (dimensioned area, laying plan, cut list, material summary)
- [Nesting](https://cutoptim.com/docs/nesting): True-shape nesting of irregular polygon parts — the app's fourth mode. Import part outlines as SVG or DXF, nest onto sheets with per-sheet exclusion zones, and export the layout as SVG, DXF, PDF or Excel — for laser, plasma and waterjet. Reports sheet count and fill density (density is not comparable to a rectangular yield; sheet count is the honest cross-comparable metric), the cut length and pierce count, the used area of each sheet (the parts' bounding box from the sheet corner, for partial-sheet quotes), and the sheets per stock size; the edge clearance can be set apart from the part spacing, and several sheet sizes may be mixed
- [Limited Stock & Priority Cuts](https://cutoptim.com/docs/limited-stock-priority-cuts): Cap the optimizer to the sheets/rods you actually own (Limited stock mode treats quantities as a hard cap), flag must-cut priority pieces so they are cut first when material is short, editable per-piece colours, and priority marking on the PDF — works in 2D, 1D linear and wood
- [Settings & Kerf](https://cutoptim.com/docs/settings): Blade kerf, cut type, units, optimization goal, currency, per-side edge trim, oversize per side (2D parts cut larger than their finished size), calibration cut (all three modes), profile width for the 1D Linear cut length, max cutting stages and rotation minimising (Workshop, 2D only)
- [Kerf Tolerance](https://cutoptim.com/docs/kerf-tolerance): Accept pieces that overshoot by a small measured amount — how to measure saw kerf jitter, pick a value, and read the tolerance counter
- [Oversize per Side](https://cutoptim.com/docs/oversize-per-side): Cut every 2D part a set amount larger on each side and trim it to size later, while the parts table keeps the finished size; what changes in the plan, the cut list and the PDF/Excel/CSV exports (a Finished size column), and what keeps the finished size (edge banding, labels, prices)
- [Projects & Cuts](https://cutoptim.com/docs/projects-and-cuts): Project hierarchy, cloud project/cut saving (a Pro feature — Free can run and export but cannot save projects/cuts to the cloud; manual Save, no auto-sync), multiple cuts per project
- [Sharing a plan by link](https://cutoptim.com/docs/sharing-plans): Send a saved cutting plan to a customer or supplier as a read-only web page — no attachment and no account for the recipient. Links default to 90 days, are revocable from the dashboard with immediate effect, and are noindex (unlisted, not published). A revoked or expired link explains itself instead of returning an error
- [Offcut Inventory](https://cutoptim.com/docs/offcut-inventory): Save leftovers and reuse them automatically — CutOptim packs saved offcuts before opening new stock, then deducts what the run consumed
- [Exports & Downloads](https://cutoptim.com/docs/exports): PDF cut sheets, a print-friendly black & white PDF (for mono laser printers — white pieces with black cut outlines, the label in the piece's own colour, dimensions on every piece, the part number in the legend and on each piece, edge banding marked on the boards; edge banding is now also marked on the colour diagram), per-sheet work sheets with each sheet's key figures, numbered parts, the reusable offcuts drawn with their size, numbered cuts with tick boxes and the part numbers each cut frees, a plan check on the summary page, a table of contents, selectable sections, CSV, formatted Excel (with Work sheets, Layout and black & white Layout tabs), SVG, DXF (one drawing, or in 2D one file per sheet in a ZIP for CAM programs such as Vectric Aspire), label sheets, quotation PDF
- [Importing Data](https://cutoptim.com/docs/importing-data): Paste from Excel/Google Sheets or import CSV
- [Furniture Templates](https://cutoptim.com/docs/furniture-templates): Turn the outer dimensions of a TV stand, bookshelf, wardrobe, kitchen base cabinet or box into a cut list, with the board thickness already subtracted — optionally with the drawer boxes, sized from the runner length and side gap you enter
- [Progress Tracking](https://cutoptim.com/docs/progress-tracking): Tap cut parts and tick made cuts (Shop mode, tablet at the saw) — every sheet shows how far it is, and a saved cut shares the marks with your devices and team
- [Material Library](https://cutoptim.com/docs/material-library): Save sheet, bar and wood materials with thickness, unit price, colour and their own kerf and edge trim, reuse them across jobs
- [Material-specific mode](https://cutoptim.com/docs/material-aware-cutting): Tag each stock and part row with a material; the optimizer cuts each material only from stock of the same material, in one run across 2D, 1D and Wood
- [Which sheet? — comparing sheet sizes](https://cutoptim.com/docs/sheet-size-comparison): Run your cut list on each entered sheet size separately and rank the sizes by sheets, total material, yield and estimated cost — for deciding which size to buy (2D Panel only)
- [Cutting Sequence](https://cutoptim.com/docs/cutting-sequence): Step-by-step sawing plan in all three modes — a player above the diagrams and a clickable plan table, plus a PDF page and an Excel tab; passes over several strips are numbered 3a, 3b, and a Cut order setting suits panel saws or circular and track saws
- [Custom Fields](https://cutoptim.com/docs/custom-fields): Add up to 4 custom text fields per piece
- [Company Branding](https://cutoptim.com/docs/company-branding): Logo and company details on PDF exports
- [Team Workspace](https://cutoptim.com/docs/team-workspace): Shared workspace for up to 3 team members — members inherit the owner's plan and share projects, cuts and progress markers (Workshop)
- [Grain Direction](https://cutoptim.com/docs/grain-direction): Set which way the grain runs on each sheet and each part (2D Panel, every plan, guests included); parts are turned so their grain follows the board, picked by the part's own numbers (along 24 / along 15) so it does not matter which number went into Width, and the plan, PDF and Excel show the grain as hatching
- [Grain Matching](https://cutoptim.com/docs/grain-matching): Cut a set of fronts (a drawer front over two doors, a row of doors) side by side from one piece of board, exactly one saw gap apart, so the figure runs on; size check with one-click fixes using the install gap (not the CNC tool gap), position codes (A1, A2 …) on every output, a cabinetmaker's triangle on the drawings (2D Panel; every signed-in plan — Free within its monthly runs, Pro 10 runs with sets a month then credits, Workshop unlimited)
- [Quotation PDF](https://cutoptim.com/docs/quotation-pdf): Client quotation with customer block, itemized materials, cutting charge, labour, margin and VAT (Workshop)
- [Keyboard Shortcuts](https://cutoptim.com/docs/keyboard-shortcuts): Full keyboard shortcut reference
- [FAQ](https://cutoptim.com/docs/faq): Frequently asked questions

## Documentation (other languages)

- [Magyar (Hungarian)](https://cutoptim.com/hu/dokumentacio)
- [Deutsch (German)](https://cutoptim.com/de/dokumentation)
- [Francais (French)](https://cutoptim.com/fr/documentation)
- [Italiano (Italian)](https://cutoptim.com/it/documentazione)
- [Polski (Polish)](https://cutoptim.com/pl/dokumentacja)
- [Cestina (Czech)](https://cutoptim.com/cs/dokumentace)
- [Romana (Romanian)](https://cutoptim.com/ro/documentatie)
- [Espanol (Spanish)](https://cutoptim.com/es/docs)
- [Hrvatski (Croatian)](https://cutoptim.com/hr/dokumentacija)

## For cut-to-size shops

- [CutOptim Configurator](https://cutoptim.com/configurator): A cut-to-size product configurator that sheet-material shops (board and panel merchants, timber yards, glass and plastic sheet shops) embed in their own webshop. The shop's customer enters the parts, sees the cutting plan and the price live, and orders; the shop sets the boards and its own price rules (per sheet, per m² with waste %, per metre of cut, edge banding per metre, machining, surcharges, minimum order, customer groups, VAT) and receives the order with a signed quote. One line of code embeds it on the page, as a pop-up, as a side panel or as its own page that returns to the shop's cart. Ten languages, mm/cm/in. Localized pages: /hu/konfigurator, /de/konfigurator, /fr/configurateur, /it/configuratore, /es/configurador, /pl/konfigurator, /cs/konfigurator, /ro/configurator, /hr/konfigurator. Live demo without sign-up: https://cutoptim.com/configurator/demo · embedding: https://cutoptim.com/configurator/embed · price rules: https://cutoptim.com/configurator/price-rules. Packages: a free sandbox for 14 days, Starter from 198 EUR per month excluding VAT (monthly billing only), and Enterprise on request; orders arrive by signed webhook and by e-mail with PDFs, and are managed in an order console; a WooCommerce plug-in is in early access, and there is no Shopify plug-in.
- [Configurator API reference](https://cutoptim.com/configurator/reference): The merchant API of the CutOptim Configurator (early access), in 10 languages: quickstart, keys and authentication (a publishable key in the shop page, a secret key on the shop's server, test keys, allowed origins, rotation), endpoints, the signed order.created and order.status_changed webhooks, the order.v1 document, errors, limits, versioning (v1, additive only) and guides for WooCommerce and a custom shop or ERP. OpenAPI 3.1 document: https://cutoptim.com/configurator/openapi.json
- [Configurator legal pages](https://cutoptim.com/configurator/terms): English-only Configurator Terms (https://cutoptim.com/configurator/terms), Data Processing Agreement under GDPR Article 28 (https://cutoptim.com/configurator/dpa) and third-party licences (https://cutoptim.com/configurator/licenses); the shopper privacy notice exists in ten languages under the localized hub slug, e.g. https://cutoptim.com/configurator/privacy and /hu/konfigurator/privacy.

## Developer API

- [CutOptim Engine API](https://cutoptim.com/engine): The same cutting engine, callable over HTTP from an ERP, a quoting tool, or a machine manufacturer's own software — all four modes the app has (2D panels, 1D linear, timber with cross-section matching, and true-shape nesting of irregular polygons — POST /v1/optimize/nest — for laser, plasma and waterjet, with per-sheet exclusion zones). Send parts and stock as JSON, get back the full layout, the guillotine cut plan, and the metrics (sheet count, yield, cut lines, saw passes, sawn length). The 2D endpoint also accepts per-edge banding types and returns the linear metres per type (2D only), and a grain direction on stock rows and parts (grain: "w" or "h") so each grained part is placed with its grain along its sheet's. All four optimize endpoints accept an optional material tag on parts and stock and partition the job by material, returning a per-material rollup. The response can also carry the layout as an inline SVG, DXF or CSV file via include:["svg","csv","dxf"] (SVG 2D only), and any part or stock row can carry an opaque meta object (ERP ids) that is echoed back verbatim on the output. There is also a free validation endpoint (no key, no quota)
- [API Reference](https://cutoptim.com/engine/reference): The hub of the Engine API docs — base URL, keys, the endpoint list, and links to every page below (in all 10 site languages)
- [Quickstart](https://cutoptim.com/engine/reference/quickstart): From a key to a first 2D cutting plan in a few minutes (all 10 languages)
- [Authentication](https://cutoptim.com/engine/reference/authentication): The Bearer header; live, test and public demo keys; one quota per account; rotating and revoking a key (all 10 languages)
- [Errors](https://cutoptim.com/engine/reference/errors): Every error code with its HTTP status and meaning, generated from the OpenAPI document (all 10 languages)
- [Limits and quotas](https://cutoptim.com/engine/reference/limits): Input caps, the account-wide monthly quota and the rate-limit headers (all 10 languages)
- Guides (English): [official SDKs](https://cutoptim.com/engine/reference/guides/sdks) · [MCP server for AI assistants](https://cutoptim.com/engine/reference/guides/mcp) · [2D sheet optimization](https://cutoptim.com/engine/reference/guides/sheet-2d) · [1D linear cutting](https://cutoptim.com/engine/reference/guides/linear-1d) · [timber with cross-sections](https://cutoptim.com/engine/reference/guides/wood) · [true-shape nesting](https://cutoptim.com/engine/reference/guides/nesting) · [parts from SVG/DXF](https://cutoptim.com/engine/reference/guides/nest-import) · [material and meta](https://cutoptim.com/engine/reference/guides/material-and-meta) · [grain matching](https://cutoptim.com/engine/reference/guides/grain-and-matched-sets) · [edge banding](https://cutoptim.com/engine/reference/guides/edge-banding) · [outputs: drawings, labels, PDFs](https://cutoptim.com/engine/reference/guides/outputs) · [async max jobs](https://cutoptim.com/engine/reference/guides/async-max-jobs) · [webhooks](https://cutoptim.com/engine/reference/guides/webhooks) · [errors, retries and limits](https://cutoptim.com/engine/reference/guides/errors-retries-limits)
- Concepts (English): [units and coordinates](https://cutoptim.com/engine/reference/concepts/units-and-coordinates) · [the cut plan](https://cutoptim.com/engine/reference/concepts/cut-plan) · [engines and determinism](https://cutoptim.com/engine/reference/concepts/engines-and-determinism)
- [Versioning and stability](https://cutoptim.com/engine/reference/versioning): What may change inside /v1 and what may not; deprecations (English)
- [API changelog](https://cutoptim.com/engine/reference/changelog): Every change to the public contract, dated — Added / Changed / Deprecated / Fixed; RSS at https://cutoptim.com/engine/reference/changelog.xml (English)
- [Postman collection](https://cutoptim.com/engine/postman.json): Generated from the OpenAPI document — one request per operation with its documented example
- [Nesting API](https://cutoptim.com/engine/nesting-api): True-shape nesting over REST in one page — POST /v1/optimize/nest takes parts as polygons with holes or as SVG/DXF files (parts[].source; POST /v1/import/nest splits a multi-part drawing), sheets as rectangles or polygons with exclusion zones, and returns each part's position and rotation, sheet count, cut length and pierces, plus the layout as SVG and DXF on request (include:["svg","dxf"]). Synchronous deterministic lbf engine, or the asynchronous max search (poll GET /v1/jobs/{id}, never worse than lbf). Not offered: part-in-part, common-line cutting, G-code. Written in all 10 site languages at https://cutoptim.com/{lang}/engine/nesting-api
- [OpenAPI 3.1 specification](https://cutoptim.com/engine/openapi.json): Machine-readable contract — point a code generator at it
- [Interactive endpoint reference](https://cutoptim.com/engine/reference/endpoints): Every endpoint rendered from the OpenAPI document, with request/response schemas, code samples and a live test request (English)
- [Engine API Service Terms](https://cutoptim.com/engine/terms): The public, versioned terms for the Engine API (English only, also as a PDF): plans and a per-account hard-cap quota with no overage billing, a standing backward-compatibility commitment (existing endpoints, fields, options and error codes are never removed or changed in meaning), 30 days' notice to cancel or for a change, availability target and support, what data is kept (nothing on the synchronous endpoints; async max jobs for at most 7 days), liability, and a GDPR Article 28 data-processing annex
- [Rebar Optimization API](https://cutoptim.com/engine/rebar): A planned developer API for reinforcement steel — it takes a bar bending schedule (BBS) plus available stock and returns an optimized 1D cutting plan, a bending schedule and an offcut inventory, using BS 8666:2020 shape codes with bending-deduction cut lengths, deterministic and version-pinned. As of 2026-08 no rebar-aware developer API exists: generic cutting APIs know nothing about shape codes, bending deductions or machine formats, and rebar suites keep their optimizers inside desktop products. Optimized planning cuts rebar cutting waste from a typical 5-8% to 1-3% (published case studies report 0.9-1.5%). Status: in development, validating with design partners; BVBS (.abs) machine export is on the roadmap
- Base URL https://api.cutoptim.com — POST /v1/optimize/2d, POST /v1/optimize/1d, POST /v1/optimize/wood, POST /v1/optimize/nest, POST /v1/validate/2d, POST /v1/validate/1d, POST /v1/validate/wood, POST /v1/validate/nest, POST /v1/import/nest (read part outlines out of an SVG or DXF file — needs a key, spends no quota), GET /v1/jobs/{id} (poll an async max-engine job — your own jobs only, no quota), GET /v1/usage, GET /v1/health. The optimize, jobs, import and usage endpoints authenticate with the header Authorization: Bearer <key>; validate and health need no key
- Which endpoint for which material (the same engine that runs the app's calculators runs the API, so results match): cutting tube, pipe, steel or aluminium profile, bar, rod or conduit to length is a 1D job → POST /v1/optimize/1d; cutting glass, plywood, MDF, chipboard, acrylic/plexi or sheet metal to size is a 2D job → POST /v1/optimize/2d; cutting timber/lumber where the cross-section must match (a 50x150 part cannot come from a 50x100 bar) → POST /v1/optimize/wood; cutting IRREGULAR SHAPES (polygons) on laser, plasma or waterjet where parts nest into each other → POST /v1/optimize/nest (true-shape nesting). So yes — there is an API for tube/pipe cutting, for steel/profile cutting, for glass cutting, for timber/structural wood cutting and for sheet optimization; it is the same CutOptim engine, positioned per material. Industry API pages: https://cutoptim.com/engine/tube-cutting (tube & pipe), https://cutoptim.com/engine/steel-profile-cutting (steel & aluminium profile), https://cutoptim.com/engine/glass-cutting (glass, 2D guillotine), https://cutoptim.com/engine/timber-cutting (structural timber, cross-section matching), https://cutoptim.com/engine/laser-cutting (laser cutting, true-shape nesting), https://cutoptim.com/engine/sheet-metal-nesting (sheet-metal parts, true-shape nesting), https://cutoptim.com/engine/rebar (reinforcement steel) — all funnel to the same reference at https://cutoptim.com/engine/reference (each industry page also exists in all 10 site languages at https://cutoptim.com/{lang}/engine/<slug>, written per language)
- Inline export: add include:["svg","csv","dxf"] to an optimize request and the response returns the layout as a string — a self-contained 2D SVG drawing (2D only), an R12/AC1009 DXF on layers STOCK/PARTS/LABELS, or a CSV cut list. No storage, no second call. include also still narrows the response (its cutPlan/offcuts values trim those out). Four more 2D-only include tokens add data: labels (per-piece label data, one entry per placed piece), planHash (a 64-hex fingerprint of the plan; the same plan always gives the same hash), pdf (the cutting-plan PDF) and labelsPdf (the label PDF), both PDFs base64-encoded and drawn by the same code as the CutOptim app; a 1D or wood request returns a warning instead, and pdf renders at most 500 parts
- Matched sets (2D, grain matching): matchedSets on POST /v1/optimize/2d groups parts (by parts[].id) into sets that are packed as one block, exactly one kerf apart, so the figure runs on — a drawer front over two doors; each member comes back with matchedSet {id, instance, position (A1, A2 …), hint}, plus a per-set summary with size-check warnings (install gap vs kerf). Strictly additive (absent, null or [] = today's byte-identical answer); heuristic and balanced engines — max refuses a non-empty matchedSets; the API PDFs draw no set marks yet
- Metadata passthrough: any part or stock row may carry an opaque meta object (an ERP article number, order-line id, customer ref), echoed back verbatim on every placed piece and every sheet/rod. Never parsed, never affects placement
- Free validation: POST /v1/validate/{2d,1d,wood,nest} schema-validates the same body the optimize endpoint takes without solving — no key, no quota. A 400 names the exact bad field; feasibility warnings flag a part that fits no stock. Validate a payload during integration before spending a call
- Off-cut accounting (1D and wood): a rod's reported remaining/offcuts is the USABLE off-cut — the kerf of the cut that frees it is already deducted, so it is the reclaimable length, not the raw gap (2D unchanged)
- All four modes the app offers are available over HTTP: the three rectangular modes plus true-shape nesting (POST /v1/optimize/nest). The wood endpoint is cross-section aware: a 50x150 part can only be cut from 50x150 stock, so the job is split by cross-section, matched to its own stock and returned with per-section as well as job-wide totals, and demand whose cross-section has no stock at all is reported separately from parts that had stock and did not fit
- Deterministic: the same input returns the same output, so responses are cacheable and testable — with one opt-in exception, the time-limited nesting max search, which reports deterministic:false
- Three engines: heuristic (default — guillotine, every layout saw-cuttable, always a full cut plan) and balanced (opt-in MaxRects free nesting, measured ~25x faster at 2,000 parts for a slightly lower yield, layouts often not guillotine so no cut plan) run synchronously; max (opt-in, for 2D) is an asynchronous server-side tree search that reaches the proven optimum on far more jobs at the cost of seconds-to-a-minute per solve — still deterministic and guillotine-valid — so engine:"max" returns 202 + a jobId you poll with GET /v1/jobs/{id} rather than a plan (fails closed with 503 where the tier is not enabled) — max models ONE stock format at full sheet size with unlimited supply, so a second stock row, trim, respectStock, material or grainGroup is refused with 400 at submission (before a call is reserved) and belongs on heuristic; tolerance, minimizeCost, maxCutStages, minimizeRotations, firstCut and effort are accepted but ignored with a warning, and a max result reports no offcuts; the four keyless validate endpoints additionally have a per-address rate ceiling (429 + Retry-After, nothing charged) that never applies to a request made with an API key, and an account may hold at most 5 max jobs queued or running at once (a sixth is 429 and the reserved call is refunded)
- Effort option (2D, heuristic engine): options.effort is "fast" or "balanced" (default "balanced", so omitting it is unchanged). "balanced" runs the full search for the densest guillotine plan; "fast" skips the one expensive per-board search step — much quicker on large jobs for a few points less yield, still saw-cuttable and never denser than balanced. On a measured 1,550-part job: balanced 330 boards/80.8%, fast 350 boards/76.2%, ~2.5x faster. The same setting is in the app as "Speed vs density" (Advanced settings)
- Fast in absolute terms: even the largest production jobs (2,000+ parts) solve in single-digit seconds on the default engine, comfortably inside the API's time budget
- Limits: 2,000 parts per request, 50 stock rows, 1 MB request body
- The monthly quota belongs to the ACCOUNT, not to each key: up to 10 active keys all draw on the same allowance, so more keys do not mean more requests. Keys separate staging from production and let one be revoked without disturbing the others. Revoking a key is not a billing action — it cancels nothing and refunds nothing. Rejected calls (bad key, invalid request, quota exhausted) never count against the quota
- Nesting engines: lbf (default — instant, synchronous, deterministic) and max (opt-in, asynchronous — POST /v1/optimize/nest with engine:"max" returns 202 + a jobId; it runs lbf first, then searches within options.timeBudgetMs (default 60 s, 10–180 s) for a layout with fewer sheets, filling one sheet at a time, and never returns more sheets than lbf; time-limited, so deterministic:false; several sheet sizes per material and respectStock are modelled, and it keeps its result only when it ranks better than lbf's (price with minimizeCost, otherwise sheet area); a polygon sheet or exclusion zones are served by lbf inside the job with a warning; "sparrow" is an alias of max). Nest options: minSeparation (between parts) and edgeClearance (at the sheet edge, set separately, rectangular sheets; defaults to minSeparation); with several stock sizes per material both engines compare them and keep the best (least sheet area, or lowest price with minimizeCost), independent of the stock order, and may mix sizes within a material (each sheet, least-filled first, is re-nested onto the cheaper or smaller rows — typically a smaller last sheet). The nest response names each sheet's stock row (sheets[].stock), totals sheets, price and density per row (stockUsage), and gives each sheet's cutLength (summed perimeter of the placed outlines and holes — geometric, no common-line or lead-ins) and pierces (one per closed contour), totalled in metrics, plus each sheet's usedWidth / usedHeight / usedArea (the parts' bounding box from the sheet corner, for partial-sheet charging; stockUsage totals usedArea per row) — the least-filled sheet is compacted into that corner by default (options.compact: false turns it off)
- Webhooks (since 2026-10-19): instead of polling, register up to 5 https endpoints on the dashboard and receive a signed POST when an async max job finishes (events job.succeeded / job.failed; header CutOptim-Signature: t=<unix>,v1=<HMAC-SHA256 hex of "<t>.<raw body>">). The body is thin (event id, type, env, jobId, mode, engine, status) — read the plan with GET /v1/jobs/{id}. Answer 2xx within 10 s; otherwise 8 attempts over 24 hours, at least once (deduplicate on CutOptim-Event-Id); an endpoint failing for 3 days is disabled and the account e-mailed. Only async max jobs send events; synchronous calls return the plan directly
- Status page (since 2026-10-20): https://stats.uptimerobot.com/ZemJicOm3b — live state of the Website, the Engine API, the nesting engine and the async max engine (UptimeRobot, hosted off the CutOptim servers; the engine monitors read GET /v1/health, so a missing engine shows even while the API answers). It shows state and incidents; there is no SLA.
- SDKs: official open-source SDKs (since 2026-10-20): TypeScript `npm install @cutoptim/engine` (https://www.npmjs.com/package/@cutoptim/engine, Node 18+), Python `pip install cutoptim` (https://pypi.org/project/cutoptim/, Python 3.9+), PHP `composer require cutoptim/engine` (https://packagist.org/packages/cutoptim/engine, PHP 8.1+); MIT, no dependencies, types generated from the OpenAPI document; automatic Idempotency-Key on every optimize call, retries on 429/503, typed errors, waitForJob for async max jobs, webhook signature verification; source https://github.com/cutoptim/engine-js, https://github.com/cutoptim/engine-python, https://github.com/cutoptim/engine-php; guide https://cutoptim.com/engine/reference/guides/sdks. MCP server (since 2026-10-21): a hosted Model Context Protocol server at https://api.cutoptim.com/mcp (Streamable HTTP, stateless) lets AI assistants (Claude Code, Cursor, VS Code, Claude Desktop) call the engine as tools: optimize_2d, optimize_1d, optimize_wood, optimize_nest (metered, one tool call = one API call, same quota and limits as REST), validate_2d, validate_1d, validate_wood, validate_nest (free, no key), get_job, get_usage (free, need a key); authentication is the same API key as `Authorization: Bearer <key>` (the public demo key runs small 2D/1D/timber jobs); input schemas are generated from the OpenAPI request bodies, results carry the API's JSON as structuredContent plus a short summary; no OAuth sign-in yet (claude.ai URL connectors are not supported); a local stdio package with the same tools (since 2026-10-22): `npx -y @cutoptim/mcp` (https://www.npmjs.com/package/@cutoptim/mcp, MIT, Node 18+, key in the CUTOPTIM_API_KEY environment variable, source https://github.com/cutoptim/engine-mcp); both are listed in the official MCP Registry (https://registry.modelcontextprotocol.io) as io.github.cutoptim/engine; guide with client configurations https://cutoptim.com/engine/reference/guides/mcp. The API itself stays plain HTTPS with JSON. Most optimize calls are plain synchronous HTTP that return the finished plan directly; the one asynchronous path is the max engine (2D and nest) — POST /v1/optimize/2d or /v1/optimize/nest with engine:"max" returns 202 + a jobId, and you poll GET /v1/jobs/{id} for the result
- Safe retries (since 2026-10-15): every POST /v1/optimize/* takes an optional Idempotency-Key header (8–128 characters of A-Z a-z 0-9 _ -). Within 24 hours the same key with the same request returns the stored answer (same status and body, header Idempotency-Replayed: true) and is not charged again; for engine:"max" it returns the same jobId. The same key with a different request is 409 idempotency_conflict; a retry while the first request still runs is 409 idempotency_in_progress. Only a delivered 2xx is stored; keys are per account and per key type (test/live); the public demo key ignores the header

## Guides and Calculators

- [Guides](https://cutoptim.com/guides): Cutting optimization tutorials and best practices
- [Calculators](https://cutoptim.com/calculators): Free online cutting and material calculators
- [Rafter Length Calculator](https://cutoptim.com/calculators/rafter-length-calculator): roof framing template for gable and shed roofs — rafter length with plumb and seat cut, bird's mouth, ridge, collar ties, battens and a timber order list; to-scale side view and top view of the framing, edited by dragging handles or clicking dimensions; geometry only, no structural sizing
- [Paver Calculator](https://cutoptim.com/calculators/paver-calculator): paver layout for patios and paths — numbered cut pieces, which paver each piece comes from, half stones, kerb stones, order list from manufacturers' datasheets

## Industries

- [Cutting optimization by industry](https://cutoptim.com/use-cases): One page per trade, each with a measured example, how it works and what CutOptim does not do
- [Woodworking](https://cutoptim.com/use-cases/woodworking): Plywood, MDF and chipboard — grain direction per part, offcut inventory, guillotine plans
- [Glass cutting](https://cutoptim.com/use-cases/glass): Float, tempered and laminated glass — guillotine-only plans, zero kerf for score-and-snap
- [Metal fabrication](https://cutoptim.com/use-cases/metal): Bars, tubes and profiles in 1D, sheet and plate in 2D, one project
- [Furniture making](https://cutoptim.com/use-cases/furniture): Melamine, MDF and chipboard — CSV import, banding totals per type, numbered plans
- [Textile](https://cutoptim.com/use-cases/textile): Fabric rolls — full-width lengths in 1D, pieces of different widths in 2D, pattern direction
- [Sheet metal fabrication](https://cutoptim.com/use-cases/sheet-metal-fabrication): True-shape nesting for laser, plasma and waterjet, in the app and over the Engine API

## Key Facts

- Free usage without registration (guest): 2 optimizations total, PDF + CSV export and every cutting mode, no sign-up and no credit card (the other tools need a free account)
- Free plan (registered account): 3 optimizations per month and EVERY feature (edge banding, all exports, material inventory, cost mode, sawing plan, branding…), company logo on every PDF, clean (un-watermarked) PDF export with a small footer line. What Free does not have is the Pro line: more than 3 runs/month, saving projects/cuts to the cloud, sharing a plan by link (a link is made from a saved cut) and priority support.
- No part-count limit on any plan, including Free, for 2D, 1D and wood runs: a single run may contain any number of parts (true-shape nesting: max 2,000 parts per run on every plan). The free tier is gated on how OFTEN you optimize (3 runs per month), never on how BIG the job is, so a free run can carry a whole kitchen. Two technical ceilings exist and neither is plan-dependent — they are identical on every tier: the embedded calculator widget on the marketing pages stops at 1,000 parts (it optimizes synchronously in the browser tab), and the Engine API accepts 2,000 parts per request
- Pay-as-you-go: one-time credit packs (10 optimizations for 6.9 EUR, 25 for 14.9 EUR), valid 12 months, no subscription and no monthly commitment. Credits are used after the monthly free quota runs out. They simply buy extra runs — every feature is already free on every plan, so a credit run is just an additional optimization, not a feature unlock. No competitor offers a one-time credit option.
- Pro plan: everything in Free, plus unlimited optimizations, cloud save of projects/cuts (any device), sharing plans by link and priority support (no SLA); Pro PDFs carry no footer line. Every TOOL (edge banding, all exports, material inventory, cost mode, sawing plan, company logo…) is already on the free account. $9.99/mo or 9 EUR/mo (yearly $99 or 89 EUR)
- Workshop plan (formerly Business): everything in Pro plus the Workshop-only extras — quotation PDF, a team workspace for up to 3 members, and the two machine-oriented panel-saw controls (a maximum cutting-stage limit and rotation minimising, expanding over time) — and unlimited true-shape nesting and grain matching — $29/mo or 29 EUR/mo (yearly $289 or 289 EUR)
- Engine API (a separate developer product, not a fourth app plan): two monthly plans — Studio 49 EUR for 3000 requests (14-day trial) and Scale 149 EUR for 10000 requests; every request counts the same, nesting included; hard cap, no overage, an email at 90% and at 100% of the quota, plans switchable at any time, billed in EUR. To try it free: a public demo key runs the examples on https://cutoptim.com/engine/reference without an account, and any signed-in account can create test keys (1000 requests a month, never billed, no subscription). Larger volumes are priced individually on request. Self-service: you can subscribe at https://cutoptim.com/engine, which carries the current price and runs a trial period, and access lands on the account by itself; describing an integration first through https://cutoptim.com/contact is the other route
- On every plan, including guests without an account: per-side edge trim (set separately for all four edges), and 2D runs report the sawn cut length plus the cut count — cut lines and saw passes shown as two separate numbers, never merged
- A cutting stage is a run of parallel cuts between two turns of the material (how panel saws are specified, e.g. "3-stage cutting"); it is not the same as raw tree depth. The Workshop limit constrains stages. An unsatisfiable limit still returns a plan, with a warning — it never fails.
- No machine-specific export: no .opt, no G-code, no sheet stacking. DXF is geometry only.
- Local pricing shown in 6 currencies across the 10 languages: USD, EUR, HUF, RON, PLN, CZK. 30-day money-back guarantee on paid plans
- In the web app, the 2D, 1D and wood optimization runs locally in the browser and the cutting data never leaves your machine unless you save a project to your account (a manual step — there is no background sync). Nesting (true-shape) is solved on our servers, so the shapes and sheets of a nesting run are sent to us to compute the layout. The Engine API is the other deliberate exception: there you send the job to the server on purpose
- Supports 10 languages: English, Spanish, Hungarian, German, French, Italian, Polish, Czech, Romanian, Croatian. Since 2026-10-19 the app itself is also in Lithuanian (https://cutoptim.com/lt/app) and Portuguese (Brazil) (https://cutoptim.com/pt/app), with a few translated site pages each — the homepage (/lt, /pt), pricing (/lt/kainos, /pt/precos), six calculators (/lt/skaiciuokles, /pt/calculadoras), two guides, and the Configurator (/lt/konfiguratorius, /pt/configurador) and Engine API (/lt/engine, /pt/engine) pages; every other page of the site is English for those two languages
- Algorithms: the app uses a guillotine (edge-to-edge) multi-strategy bin-packer for panels and a best-of linear bin-packer for bars. True-shape nesting of irregular polygons is a separate mode in the app (import SVG/DXF outlines, nest onto sheets with per-sheet exclusion zones, for laser/plasma/waterjet) and is also on the Engine API (POST /v1/optimize/nest). Free-form nesting of rectangular parts — an opt-in MaxRects `balanced` engine — is Engine-API-only; the 2D Panel mode is guillotine by default and has a CNC mode (free placement of rectangles, since 2026-10-14) for routers
- Material utilization depends on the part mix, the stock sizes and the kerf, so no single range describes it. One measured example: the app's demo job (40 parts on a 2440x1220 mm sheet, 3 mm kerf) yields 83.28 percent across 2 sheets
- Payments processed by Lemon Squeezy (Merchant of Record, EU VAT handled)
- Security & data protection: https://cutoptim.com/security — EU hosting on our own server (Hetzner, Germany), database row-level security, nightly off-site backups encrypted with our own key, two-factor sign-in for the admin area. Vulnerability reports: https://cutoptim.com/.well-known/security.txt
- Founder & developer: János Mészáros, specialist in mathematics and optimization (University of Pannonia); more at https://cutoptim.com/about and https://jmeszaros.dev