# Technical Drawing Reader (`kuntran-labs/technical-drawing-reader`) Actor

Turn PDF or image drawings of machined parts into structured JSON: title block, material, ISO 2768 general tolerances, fits with computed tolerance bands, threads, GD\&T, surface roughness and quoting flags.

- **URL**: https://apify.com/kuntran-labs/technical-drawing-reader.md
- **Developed by:** [Kuntran Ampalavanesan](https://apify.com/kuntran-labs) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $300.00 / 1,000 drawing pages

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Technical Drawing Reader do?

Technical Drawing Reader turns **PDF or image drawings of machined parts** into **structured JSON**. Upload a drawing (or paste a link) and get the data a quoting engineer or CNC shop types in by hand:

- **Title block**: drawing number, revision, title, part number, scale, sheet, projection method
- **Material**, with grade and condition split out (for example `42CrMo4+QT`, `EN AW-6082-T6`)
- **General tolerance** (ISO 2768), normalised to `ISO 2768-mK` style
- **Every toleranced dimension**: deviations, ± tolerances, limit sizes and **ISO 286 fits with the tolerance band computed in code** (Ø20 H7 → +0.021 / 0)
- **Threads**: metric, UNC/UNF, trapezoidal, pipe. Includes pitch, class, depth, and internal or external
- **GD\&T** feature control frames: characteristic, value, diametral zone, datums
- **Surface roughness**, including old N-grades converted to Ra
- **Heat and surface treatments**, edge requirements, notes
- **Attention points for quoting**: the tightest tolerance, the finest finish, fine-pitch threads, heat treatment and more, in plain sentences

It reads the drawing like a person would, using an AI vision model. It then **checks the reading with deterministic engineering rules** and adds warnings when something looks wrong.

### Why use it?

- **Faster quoting**: see in seconds whether a part has a 0.013 mm band, a cylindricity of 0.005 or a hardened surface, before anyone opens the CAD model.
- **Feed your systems**: push drawing data into an ERP, MES, spreadsheet or RFQ tool via the Apify API, webhooks or integrations (Make, Zapier, n8n, Google Sheets).
- **Bulk intake**: run hundreds of supplier or customer drawings at once and filter them by material, tolerance or treatment.
- **Fewer typos**: tolerance bands come from the ISO 286 tables, not from the AI's arithmetic.

### How to use it

1. Click **Try for free**. The input is prefilled with a sample drawing, so you can see the output right away.
2. Paste **links** to your drawings under *Drawing links*, or **upload** files under *Upload drawings*.
3. Optional: set *Max sheets per drawing* (default 3) and *Drawings in parallel*.
4. Click **Start** and open the **Output** tab: one row per drawing.

Supported files are **PDF** (vector or scanned), **PNG, JPG, TIFF and WebP**. Each link must be a direct download link that doesn't need a login.

### Input example

```json
{
  "drawingUrls": [
    "https://example.com/drawings/part-1001.pdf",
    "https://example.com/drawings/part-1002.png"
  ],
  "maxPagesPerDrawing": 3,
  "maxConcurrency": 3
}
```

### Output example

One item per drawing (shortened; the full item also has `details` with every dimension, thread, GD\&T frame and roughness callout):

```json
{
  "status": "ok",
  "fileName": "sample-shaft.pdf",
  "drawingNumber": "TDR-1002",
  "revision": "A",
  "title": "DRIVE SHAFT",
  "material": "42CrMo4+QT",
  "generalTolerance": "ISO 2768-fH",
  "units": "mm",
  "tightestTolerance": 0.013,
  "tightestToleranceCallout": "2x Ø25 k6",
  "tightestGeometricTolerance": 0.005,
  "tightestGeometricCallout": "Cylindricity 0.005",
  "finestRoughnessRa": 0.4,
  "toleratedDimensionCount": 6,
  "threadCount": 1,
  "gdtCount": 3,
  "attentionPoints": [
    "Tight tolerance: 0.013 mm band on \"2x Ø25 k6\"",
    "Very tight geometric tolerance: cylindricity 0.005 mm",
    "Fine surface finish required: Ra 0.4 µm",
    "Heat treatment: Induction hardened 50-55 HRC, depth 1-1.5 mm on Ø25 seats",
    "Fine-pitch thread: M16x1.5-6g"
  ],
  "warnings": [],
  "pagesCharged": 1
}
```

A dimension inside `details.toleratedDimensions`:

```json
{
  "raw": "Ø30 h7",
  "nominal": 30.0,
  "fitClass": "h7",
  "upperDeviation": 0.0,
  "lowerDeviation": -0.021,
  "toleranceBand": 0.021,
  "toleranceSource": "iso286"
}
```

`toleranceSource` tells you where a band comes from:

- `drawing`: printed on the sheet.
- `iso286`: computed from the fit class, with exact limits.
- `iso286-band-only`: computed from the fit class. The band width is exact, but the limits aren't given for that deviation letter.

The **Overview** and **Problems** tabs in the Output show the key fields and any warnings at a glance. You can download everything as JSON, CSV, Excel or HTML.

### How much does it cost?

This Actor uses **pay-per-event** pricing: you pay **per drawing sheet analysed** (event `drawing-page-analyzed`). The price is shown on the Actor's pricing tab.

- A typical one-sheet part drawing costs **one event**.
- Only the first *Max sheets per drawing* sheets of each file are read and charged.
- Sheets that fail to read are **not charged**.
- The bundled sample drawings and the empty-input demo are **free**.
- **Your spending limit is respected.** Before a drawing is read, its sheets are reserved against your maximum cost for the run. When the limit is reached, the remaining drawings are marked `skipped` and not charged.

### Accuracy and limitations

Please read this before relying on the output.

- The output is **an aid for quoting and data entry, not a replacement for engineering review.** Always check critical values against the drawing before manufacturing or committing to a price.
- Clean CAD exports (vector PDF) give the best results. Low-resolution scans, handwriting, heavy hatching over text or very dense sheets can cause missed or misread callouts. Each item includes `warnings` and per-section `confidence` values, and readings below 0.6 confidence are flagged.
- ISO conventions are assumed (ISO 286, ISO 2768, ISO 1302, ISO 261). Inch drawings are read, but ISO fit calculations are not applied to them.
- Only fields printed on the drawing are returned. **Person names (designer, checker, approver) are deliberately not extracted.**
- 3D models (STEP, IGES), DXF/DWG files and multi-part assembly BOMs are not supported.

### Privacy

Drawings are downloaded only to process the run and are sent to the AI provider to be read. They are not used to train models. Links to private networks are refused. Only use drawings you're allowed to share with a third-party processor.

### FAQ

**Can I process drawings from Google Drive or Dropbox?**
Yes, if the link is a public *direct download* link, not a preview page.

**Why does Apify ask me to approve permissions on the first run?**
The Actor needs permission to read the drawing files you upload through the *Upload drawings* field, which are stored in your own Apify storage. It only reads the files you give it in the input.

**What happens with a multi-sheet PDF?**
Each sheet up to *Max sheets per drawing* is read, and the results are merged into one item per file. The title block is taken from the first sheet that has one, and all dimensions are listed with their page number.

**Can I call it from my own software?**
Yes. Use the [Apify API](https://docs.apify.com/api/v2) or one of the API clients. Start a run with the input JSON above and read the default dataset.

**Something was read wrong. What can I do?**
Check `warnings`, `confidence` and the `raw` text of the callout. Please report systematic problems through the **Issues** tab with a drawing you're allowed to share. That's how the reader gets better.

# Actor input Schema

## `drawingUrls` (type: `array`):

Direct download links to technical drawings: PDF, PNG, JPG, TIFF or WebP. One drawing per link. Leave empty (and upload nothing) to get a free demo result.

## `drawingFiles` (type: `array`):

Or upload drawing files from your computer. Each file is one drawing.

## `maxPagesPerDrawing` (type: `integer`):

Only the first N sheets (pages) of each file are read and charged. Most part drawings have one sheet.

## `maxConcurrency` (type: `integer`):

How many drawings are read at the same time.

## Actor input object example

```json
{
  "drawingUrls": [
    "https://raw.githubusercontent.com/Kuntran-25/technical-drawing-reader-samples/main/samples/sample-bushing.pdf"
  ],
  "drawingFiles": [],
  "maxPagesPerDrawing": 3,
  "maxConcurrency": 3
}
```

# Actor output Schema

## `results` (type: `string`):

One item per drawing: title block, material, tolerances, threads, GD\&T, roughness and quoting flags.

## `runSummary` (type: `string`):

How many drawings were read, failed or skipped, and how many sheets were charged.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "drawingUrls": [
        "https://raw.githubusercontent.com/Kuntran-25/technical-drawing-reader-samples/main/samples/sample-bushing.pdf"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kuntran-labs/technical-drawing-reader").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "drawingUrls": ["https://raw.githubusercontent.com/Kuntran-25/technical-drawing-reader-samples/main/samples/sample-bushing.pdf"] }

# Run the Actor and wait for it to finish
run = client.actor("kuntran-labs/technical-drawing-reader").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "drawingUrls": [
    "https://raw.githubusercontent.com/Kuntran-25/technical-drawing-reader-samples/main/samples/sample-bushing.pdf"
  ]
}' |
apify call kuntran-labs/technical-drawing-reader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kuntran-labs/technical-drawing-reader"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/2mL5slicFbLu2TwpR/builds/RE4Ukd6sNu0bFBxrC/openapi.json