SmartCut

dev.smartcutPublished by smartcut.devOfficial publisherv1.0.0Updated Nov 2, 2026

Cutlist optimization for sheet, linear and roll stock, with grain, kerf, nesting and saw exports.

VerifiedStreamable HTTPWeb executableDeveloper ToolsBusiness & Commerce

Overview

AI-generated overview

Hosted SmartCut MCP server that lets an assistant run cutting-stock optimisation for sheet, linear and roll stock and export saw-ready layouts.

What you can do
  • Submit, validate and cancel cutting optimisations, then check status and fetch the resulting layouts
  • Export results as PDF, CSV, DXF, SVG, PTX, Biesse XML or Mayer .may, and list saws with their formats
  • Generate printable part labels from a result
  • Check API usage statistics
  • Push parts extracted from a PDF or photo of a cutting plan into an open Cutlist Evolution editor for the user to confirm
When to use it
Useful for quoting, cut-to-size order processing, e-commerce checkout and CAM hand-off where you want optimisation quality and machine-ready saw output without maintaining a geometry engine. Not suitable if you need an in-process packer with no network call or account.
Requirements
Remote streamable HTTP endpoint at api.smartcut.dev; no local package. A SmartCut API key is required, sent as the raw value in the Authorization header with no Bearer prefix. A paid subscription account is needed, and network access to the service.
Before you install
The API key is a billable credential: keep it secret and send it raw, since a Bearer prefix returns 401. The service is a subscription, so calls may consume paid quota; usage can be checked with the usage tool. The import_parts tool writes parts into an open Cutlist Evolution editor, and calculate submits jobs to a third-party hosted service.

Installation

In SourceWeft

  1. Open SmartCut in the dashboard and add it to a workspace.
  2. Connect Authorization token credentials. They are stored privately and never shown on public pages.
  3. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/dev.smartcut%2Fcutlist-optimizer/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "smartcut": {
      "type": "http",
      "url": "https://api.smartcut.dev/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      }
    }
  }
}

README

SmartCut API

SmartCut is a hosted cutting-optimisation (cutlist / nesting) API for sheet, linear and roll stock. This repository holds the OpenAPI specification, runnable examples and MCP configuration for integrating it into your own software.

[Licence: MIT] [OpenAPI 3.0] [Docs]

What it does

  • Sheet optimisation — guillotine (edge-to-edge, saw-cuttable) and efficiency modes for plywood, MDF, glass, plastic and sheet metal.
  • Linear (1D) optimisation for timber, bar, pipe and extrusion.
  • True-shape nesting for irregular parts from DXF, for laser, plasma, waterjet and CNC routing.
  • Grain direction and per-part orientation locks, so a part can be pinned to the length or width of the grain, or left free to rotate.
  • Edge banding, face finishes, blade kerf and stock trim as first-class inputs, not post-processing.
  • Machine-ready exports — PDF, CSV, DXF, SVG, and native saw formats including PTX (Homag), Biesse XML and Mayer .may.
  • Printable part labels generated from the same result.

Quickstart

Get a key at https://smartcut.dev/account, then:

bash
curl -X POST https://api.smartcut.dev/v3/calculate \  -H "Authorization: $SMARTCUT_API_KEY" \  -H "Content-Type: application/json" \  -d @examples/requests/guillotine.json

That returns a job id. Poll until it is ready, then fetch the result:

bash
curl "https://api.smartcut.dev/v3/result/ready?id=$JOB_ID" -H "Authorization: $SMARTCUT_API_KEY"curl "https://api.smartcut.dev/v3/result?id=$JOB_ID"       -H "Authorization: $SMARTCUT_API_KEY"

The result carries one entry per stock piece, each listing the parts placed on it with their positions, the cuts needed to produce them, and the offcut left over. Complete runnable versions in four languages are in examples/.

Authentication

Pass the raw API key in the Authorization header:

Authorization: YOUR_API_KEY

There is no Bearer prefix. This is the single most common integration mistake — a Bearer prefix returns 401.

Endpoints (v3)

methodpathwhat it doessync
POST/v3/calculateSubmit calculationasync
POST/v3/validateValidate inputs without calculatingsync
POST/v3/model/analysisAnalyse a 3D model into partssync
GET/v3/result/readyCheck if calculation is completesync
GET/v3/resultRetrieve calculation resultsync
GET/v3/export/pdfExport result as PDFsync
GET/v3/export/csvExport result as CSVsync
GET/v3/export/ptxExport result as PTXsync
GET/v3/export/dxfExport result as DXFsync
GET/v3/export/svgExport result as SVGsync
GET/v3/export/mayerExport result as Mayer .maysync
GET/v3/export/biesseExport result as Biesse XML CutListsync
GET/v3/sawsList saws and the export formats each offerssync
POST/v3/labelsGenerate printable part labelssync
POST/webhooks/resultCalculation result delivery— your endpoint
GET/v3/callsGet API usage statisticssync

Full reference: https://smartcut.dev/api-docs/v3

How the async model works

Optimisation takes longer than a request should block for, so /v3/calculate returns a job id immediately. You then either poll /v3/result/ready until it reports done, or register a webhook and let SmartCut POST to you when the result is available. Either way you fetch the payload from /v3/result.

Webhook registration, signature verification and retry behaviour are documented at https://smartcut.dev/docs/webhooks.

MCP server

SmartCut runs a hosted Model Context Protocol server, so an agent can run optimisations directly with your existing API key.

POST https://api.smartcut.dev/mcp

Streamable HTTP transport. Authentication is the same raw key in the Authorization header, without a Bearer prefix. Configuration for Claude Desktop and other clients is in mcp/.

Tools: calculate, validate, status, result, cancel, usage, export, labels, list_cut_types — plus import_parts, which is different from the rest: it pushes parts an agent has extracted (from a PDF or a photo of a cutting plan) into an open Cutlist Evolution editor for the user to confirm, rather than calling the optimisation API.

The calculate tool waits for the result in-call (about 25 seconds by default, overridable with waitMs) and falls back to returning a job id if the optimisation is still running, so an agent usually gets a layout in one call.

Generating a client

There is no official SDK, and that is deliberate. The API is a JSON body and one header, so fetch is already the client — and a generated client in your own idiom will fit your codebase better than a hand-written one would. Point any generator at the spec:

bash
npx openapi-typescript openapi/v3.json -o smartcut.d.tsnpx @hey-api/openapi-ts -i openapi/v3.json -o src/smartcutopenapi-generator-cli generate -i openapi/v3.json -g python -o ./smartcut-python

Examples

languagefile
curlexamples/curl/optimise.sh
Nodeexamples/node/optimise.mjs
Pythonexamples/python/optimise.py
PHPexamples/php/optimise.php

Each reads a payload from examples/requests/, which is generated from the specification — so the examples cannot drift from the schema.

What this is, and is not

SmartCut is a hosted service with a subscription, not a self-hosted library. It suits quoting, order processing, e-commerce cut-to-size checkout and CAM hand-off, where you want optimisation quality and saw-format output without maintaining a geometry engine. If you want an in-process bin-packer with no network call and no account, this is the wrong tool and an open-source packing library is the right one.

Links

Support

Issues here are for the specification and the examples only. For API access, billing, quota or integration support, use the contact form at https://smartcut.dev/contact. Specification files are generated and cannot be changed by pull request — see openapi/README.md.

Source: README.md at commit 46b15af

Tools

0
This server asks for a credential such as an API key, so SourceWeft could not read its tools without one and has not indexed them.

Version history

1
  1. v1.0.0LatestSep 16, 2026

Score

75% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts

    Declare a license in the repository or the registry entry.