Use case · Manufacturing Quotation

Extract part geometry from DWG/DXF to drive automated quoting.

CADLens parses customer-supplied part drawings into structured vector JSON — entities, layer data, and bounding box — so your quotation engine can read hole counts, path lengths, and feature geometry programmatically. No CAD software on your servers, no manual interpretation.

Join the beta · Free 50/mo →Read the docs
01THE PROBLEM

Manual part review slows every quote.

Quoting a machined or sheet-metal part requires reading the drawing: how many holes, what total cut length, which features sit on which layers, what are the overall dimensions? When a customer uploads a DWG or DXF, someone has to open a CAD tool, measure, and transfer numbers into the quoting system by hand. That adds minutes or hours per quote and introduces transcription errors.

Automating this step requires parsing the CAD file programmatically — something that is surprisingly hard to do reliably across the range of DWG versions and DXF dialects real customers produce.

02HOW CADLENS HELPS

Structured geometry, ready to compute.

When a customer uploads a part drawing, your backend sends it to POST /v1/parse. CADLens returns three data objects your quotation logic can act on directly:

  • vectorJson — every entity in the drawing with its type, layer, and geometry. Count circles for hole features, sum polyline vertex distances for cut length, inspect text entities for tolerances or part numbers.
  • layersJson — layer names, colors, and per-layer entity counts. Map layers to operations (cuts, bends, engravings) or materials using your own layer-naming conventions.
  • metadata — drawing units and bounding box (width, height). Use this for blank size and material sheet utilisation estimates.

A PNG preview is also available so your quotation UI can show the customer exactly what was parsed before confirming the quote.

03API WORKFLOW

From file upload to quote data in one call.

The typical integration in a manufacturing quotation platform:

  1. Customer uploads a DWG or DXF in your quoting UI. Your server receives the file and forwards it: POST /v1/parse with multipart/form-data and your Authorization: Bearer <api_key> header. For files under ~2 MB add wait=true to block on the response.
  2. For larger files you receive a job_id immediately. Poll GET /v1/jobs/{job_id} (status: PENDING → PROCESSING → COMPLETED) or register a webhook_url on the parse request to be notified on completion.
  3. Fetch GET /v1/jobs/{job_id}/result to get the full vectorJson, layersJson, and metadata.
  4. Run your feature-extraction logic against the result and populate the quotation form automatically.
04RELEVANT DATA

Fields that matter for quotation.

Not every field in the response is relevant to quoting. The ones that drive pricing logic:

  • entities[].type — filter to "circle" for hole counts, "polyline" for cut profiles, "arc" for radii and corners, "text" for tolerance annotations.
  • entities[].vertices — array of { x, y } points on polylines. Sum segment distances for cut length in the drawing's native units.
  • entities[].closed — boolean on polylines. A closed profile is a complete cut contour; open profiles may be slots, partial cuts, or annotation lines.
  • entities[].layer — the layer name for each entity. Cross-reference with layersJson for the layer color and total entity count on that layer.
  • metadata.boundingBox{ width, height } in drawing units. Convert to mm or inches using metadata.units for blank-size estimation.
05EXAMPLE OUTPUT

What the response looks like.

A simplified extract from a /v1/jobs/{job_id}/result response for a sheet-metal bracket drawing (schema version 2024-01):

{
  "schemaVersion": "2024-01",
  "metadata": {
    "units": "mm",
    "boundingBox": { "width": 240.0, "height": 180.0 }
  },
  "layersJson": [
    { "name": "CUTS",  "colorHex": "#FF0000", "entityCount": 12 },
    { "name": "HOLES", "colorHex": "#00FF00", "entityCount":  8 },
    { "name": "BENDS", "colorHex": "#0000FF", "entityCount":  4 }
  ],
  "vectorJson": [
    {
      "type": "polyline",
      "layer": "CUTS",
      "closed": true,
      "vertices": [
        { "x": 0.0,   "y": 0.0 },
        { "x": 240.0, "y": 0.0 },
        { "x": 240.0, "y": 180.0 },
        { "x": 0.0,   "y": 180.0 }
      ]
    },
    {
      "type": "circle",
      "layer": "HOLES",
      "center": { "x": 30.0, "y": 30.0 },
      "radius": 4.5
    }
  ]
}

From this response, a quotation engine can determine: outer profile cut length (2 × (240 + 180) = 840 mm), 8 holes of radius 4.5 mm on the HOLES layer, 4 bend features, and a blank size of 240 × 180 mm.

06LIMITATIONS

What to keep in mind.

CADLens extracts geometry as drawn. It does not interpret manufacturing intent beyond what is encoded in the file:

  • Nested blocks — block inserts (type: "insert") are returned with their insertion point and block name but are not automatically exploded. If your customers nest geometry inside blocks, you will need to resolve references using the insert entity data.
  • 3D drawings — entities include Z coordinates where present, but CADLens is optimised for 2-D part drawings. Complex 3D solid models (ACIS/SAT) are not yet extracted.
  • Drawing conventions — whether a circle represents a hole, a boss, or a annotation symbol depends on your customers' CAD conventions. Layer-naming conventions on your end are the most reliable discriminator.
  • Unitsmetadata.units reflects what is set in the drawing file. If a customer saves in inches without noting this, your length calculations must apply the correct conversion.
07 — FAQ

Common questions.

Yes. Circles in vectorJson represent holes or round features. Filter entities where type === "circle" and sum them per layer or across the drawing. Radius is included in the entity geometry so you can distinguish hole sizes.

Polyline entities in vectorJson carry a vertices array of {x, y} points. Sum the Euclidean distance between consecutive vertex pairs. For closed polylines (closed: true) add the closing segment. Arc entities include center, radius, startAngle, and endAngle so arc length is straightforward to derive.

Yes. CADLens accepts DWG, DXF, and DWF natively. No pre-conversion is required.

layersJson returns each layer name alongside its colorHex and entityCount. Most manufacturers use layer naming conventions — for example, CUTS, BENDS, ENGRAVE — so you can route entities by layer name to the matching process or cost table in your quotation engine.

The current API parses the model space of a drawing. Block inserts (type: "insert") are included in vectorJson with their insertion point, block name, and scale. Full assembly exploding (traversing nested blocks) is on the roadmap.

For part drawings under ~2 MB, passing wait=true on POST /v1/parse returns the result in a single HTTP round-trip, typically under 3 seconds. Larger or more complex drawings use async polling or a webhook.

JOIN THE BETA

Start parsing part drawings. Free 50 parses/month.

Connect your quotation engine to the CADLens API. No CAD software to install or maintain.

Join the beta · Free 50/mo Read the docs
— RELATED

Keep reading.