# Maglev

> Maglev connects AI agents to manufacturing: upload CAD, check manufacturability, get quotes from many shops, and place human-approved orders through MCP or a REST API.

> ## Agent Instructions
> To use Maglev from an agent, connect the MCP server at https://trymaglev.com/mcp. Parts catalog tools need no key. Make tools (make_start, check_manufacturability, get_quotes, place_order) need a Maglev key; see https://trymaglev.com/docs/quickstart.
> Never place an order without showing the person the exact final total and getting their explicit approval.

# Resources for AI agents: llms.txt, MCP and Markdown
Source: https://trymaglev.com/docs/agent-resources

Every machine-readable Maglev entry point in one place: MCP servers, llms.txt files, Markdown pages, OpenAPI and JSON endpoints, and the rules agents must follow.

Maglev is built to be used by AI agents. This page lists every entry point an agent can read or connect to, so it can find the right one without crawling.

## Connect

| Resource | URL |
| - | - |
| Maglev MCP server (make parts, search parts) | `https://trymaglev.com/mcp` |
| Make REST API | `https://trymaglev.com/api/v1` |
| Parts catalog JSON API | `https://trymaglev.com/parts/api/index.json` |
| Manufacturer directory JSON API | `https://trymaglev.com/make/api/index.json` |

## Read

| Resource | URL |
| - | - |
| Company overview for agents | [trymaglev.com/llms.txt](https://trymaglev.com/llms.txt) |
| These docs, as an index | [trymaglev.com/docs/llms.txt](https://trymaglev.com/docs/llms.txt) |
| These docs, full text | [trymaglev.com/docs/llms-full.txt](https://trymaglev.com/docs/llms-full.txt) |
| Any docs page as Markdown | Add `.md` to the page URL, for example `https://trymaglev.com/docs/quickstart.md` |
| Parts catalog for agents | [trymaglev.com/parts/llms.txt](https://trymaglev.com/parts/llms.txt) and [llms-full.txt](https://trymaglev.com/parts/llms-full.txt) |
| Parts catalog OpenAPI | [trymaglev.com/parts/openapi.json](https://trymaglev.com/parts/openapi.json) |
| Manufacturer directory for agents | [trymaglev.com/make/llms.txt](https://trymaglev.com/make/llms.txt) |

Every page of these docs has a menu with **Copy page**, **View as Markdown**, and options to open it in Claude, ChatGPT or Perplexity, or add it to Cursor or VS Code.

## Rules for agents

* Show the person every offer from `get_quotes`. Do not pick a winner for them.
* Never place an order without showing the exact final total from `place_order` and getting the person's explicit approval. Put their words in `approval_note`.
* Report `unknown` values as unknown. Do not fill them in.
* Keep Maglev keys in the environment or a secret manager. Never paste them into prompts, commands you show, or files you commit.


# Make API reference: endpoints, fields and errors
Source: https://trymaglev.com/docs/api-reference/make-api

Maglev Make REST API at trymaglev.com/api/v1: files, check, quotes, requests and orders endpoints, offer fields, order statuses, idempotency and error codes.

The Make API is the REST version of the Maglev make flow. Base URL: `https://trymaglev.com/api/v1`

Every call needs `Authorization: Bearer mgl_…`. Create a key on the [dashboard](https://trymaglev.com/dashboard#keys) (**API keys** → **Create secret key**). Keys are personal; requests made with them show up in every workspace you belong to. Requests and responses are JSON, except file upload, which is `multipart/form-data`. `/api/make/*` is an alias for the same endpoints.

## Endpoints

| Method | Path | What it does |
| - | - | - |
| `GET` | `/me` | Who this key belongs to. The first call to try a new key |
| `POST` | `/files` | Upload one STEP or harness file. Returns its `file_id` and route |
| `GET` | `/files/{file_id}` | The file's size, bounding box, bodies and route |
| `POST` | `/check` | Whether each file can be made, and why it went to its process |
| `POST` | `/quotes` | Every shop's offer for each file. Returns a `request_id` |
| `GET` | `/requests` | Your requests, newest first: parts, offers and orders |
| `GET` | `/requests/{request_id}` | One request |
| `GET` | `/quotes/{quote_id}` | One offer and its order, if any |
| `POST` | `/orders` | Ask for the final total, or place an approved order |
| `GET` | `/orders/{quote_id}` | The order for an offer |

## POST /files

Form field `file`. Accepts `.step`, `.stp` (CAD) and `.json` (wire harness spec). Up to 20 MB. Kept 7 days.

| Field | Meaning |
| - | - |
| `file_id` | Use this in every later call |
| `bbox_mm` | Bounding box, millimeters |
| `bodies` | Number of solid bodies. A STEP with no solid body is a blocker |
| `suggested_process` | `cnc_machining`, `sheet_metal`, `injection_molding` or `wire_harness` |
| `route_reason` | Why, read from the geometry |

Returns `201`.

## POST /check

| Field | Type | |
| - | - | - |
| `file_ids` | string\[] | Required |
| `processes` | object | Optional. `{ file_id: process }` to override the route |
| `options` | object | Optional. `{ file_id: { material, quantity } }` |

Response: `ready_to_quote` (boolean) and `files[]`, each with `process`, `routed_because`, `ok` and `issues[]` (`severity` is `blocker` or `warning`).

## POST /quotes

| Field | Type | |
| - | - | - |
| `file_ids` | string\[] | Required |
| `quantity` | integer | Required, 1 to 100000 |
| `sort` | string | Optional. `price` (default) or `lead_time`. You choose; Maglev never picks a winner for you |
| `processes` | object | Optional route override |
| `options` | object | Optional per-file `material` or `quantity` |

Every shop that makes a part's process is asked in parallel: for CNC and sheet metal that is around 10 shops in the US, China and Europe (directly and through the Agentic Fabrication Network); molding goes to SSG MFG and harnesses to MiniProto. Typical time is 10 to 20 seconds. Returns `201`:

```json theme={null}
{
 "request_id": "rq_…", "quantity": 10, "sort": "price", "seconds": 13.4,
 "total_usd": 7265, "total_note": "Sum of the first offer per part …",
 "parts": [
  { "file": "joint_housing.step", "file_id": "f_…", "process": "cnc_machining",
    "routed_because": "solid with pockets, bores and holes …",
    "offers": [
     { "quote_id": "mq_…", "shop": { "name": "Justway", "country": "CN", "via": "AFN" },
       "price_type": "firm", "currency": "USD", "quantity": 10,
       "total_usd": 226.35, "total_minor": 22635, "unit_price_usd": 22.64,
       "one_time_costs": [], "lead_time_days": 11, "ships_by": null, "arrives_by": "2026-11-20",
       "shipping_options": [{ "id": "…", "carrier": "DHL", "cost_usd": 62.59, "arrives": "2026-11-20" }],
       "material": "aluminum_6061", "valid_until": "2026-11-10T10:29:26Z", "source": "shop_api" }
    ] }
 ]
}
```

Offer fields:

| Field | Meaning |
| - | - |
| `price_type` | `firm` is the shop's own live price. `budgetary` is an estimate the shop confirms before you pay (molding, some shops) |
| `total_usd`, `total_minor` | The parts price in dollars and in cents. Shipping and tax are not included unless the shop included them |
| `one_time_costs[]` | Tooling or setup, already inside `total_usd`, listed so you can see it |
| `lead_time_days` | Calendar days until it ships or arrives, from the shop's date or range. `null` when the shop didn't say |
| `ships_by` / `arrives_by` | The shop's own date, whichever it gave |
| `valid_until` | When the shop's price expires, when the shop says |

A value the shop didn't give is `null`, never a guess. A shop that fails doesn't fail the call: its offer has `ok: false` and an `error`. Offers are kept 7 days.

## POST /orders

| Field | Type | |
| - | - | - |
| `quote_id` | string | Required. The offer to order |
| `approved_total_usd` | number | The exact final total a person approved |
| `approval_note` | string | Who approved it, and how |

Without `approved_total_usd`, or if it doesn't match the final total, nothing happens. The response is `needs_approval` with `final_total_usd` and an `ask_human` sentence to show a person.

| `status` | Meaning |
| - | - |
| `needs_approval` | Show `ask_human` to a person, then call again with the total |
| `ordered` | Paid. `order_url` tracks it |
| `checkout_created` | Open `checkout_url` to pay at the shop |
| `rfq_sent` | Request for quote sent to the shop |
| `orders_disabled` | Ordering is switched off for this account. Nothing was charged |
| `over_limit` | Over the per-order limit. Nothing was charged |

Ordering the same offer again returns the existing order with `already_ordered: true`.

## Retries and idempotency

Send `Idempotency-Key: <any unique string>` on any `POST`. Repeating the call with the same key and body within 24 hours returns the first response again (header `Idempotent-Replayed: true`) instead of quoting or ordering twice. The same key with a different body returns `422 idempotency_conflict`.

## Errors

Every response carries an `X-Request-Id` header. Errors use HTTP status codes and one shape:

```json theme={null}
{ "error": { "code": "invalid_request", "message": "quantity must be a whole number from 1 to 100000.", "request_id": "req_…" } }
```

| Status | `code` | When |
| - | - | - |
| 400 | `invalid_request` | A field is missing or wrong. The message says which |
| 401 | `unauthorized` | No key, or the key was revoked |
| 404 | `not_found` | No such file, request, quote or order on this account |
| 413 | `file_too_large` | Over 20 MB |
| 415 | `unsupported_file` | Not a STEP or harness JSON file |
| 422 | `idempotency_conflict` | Idempotency-Key reused with a different body |
| 502 | `upstream_error` | A shop did not answer. Retry the call |


# Authenticate with a Maglev API key
Source: https://trymaglev.com/docs/authentication

Create a Maglev API key on the dashboard or with connect.sh, send it as a Bearer token, and check it with GET /me before making manufacturing requests.

Maglev authenticates every Make request with a personal API key sent as `Authorization: Bearer mgl_…`. The same key works for the MCP server at `https://trymaglev.com/mcp` and the REST API at `https://trymaglev.com/api/v1`. The parts catalog and manufacturer directory need no key.

## Get a key

> [tab] Dashboard
>
> Log in or sign up at [trymaglev.com/dashboard](https://trymaglev.com/dashboard#keys), open **API keys** in the sidebar, and choose **Create secret key**. Name the key. It is shown once, with a Copy button, and the dashboard checks it against `GET /api/v1/me` right away.

> [tab] connect.sh
>
> The [quickstart](/docs/quickstart) command signs you in through the browser and saves a key to `~/.maglev/token`. Keys saved this way work the same as dashboard keys.

Keep the key in your environment or a secret manager, never in prompts or committed files:

```bash theme={null}
export MAGLEV_KEY=mgl_...
```

## Check a key

```bash theme={null}
curl https://trymaglev.com/api/v1/me -H "Authorization: Bearer $MAGLEV_KEY"
```

A missing or revoked key returns `401` with error code `unauthorized`. Over MCP, a Make tool called without a key returns a message telling the agent how to connect.

## Keys and teams

Keys are personal. Requests made with your key appear in every workspace you belong to. On the dashboard, **Members** then **Invite people** adds teammates by email; everyone in a workspace sees the same requests, offers, orders and usage. Each person creates their own key, and revoking a key affects only its owner.


# Make parts from CAD: STEP file to quotes and orders
Source: https://trymaglev.com/docs/how-to/make-parts-from-cad

Upload STEP files to the Maglev REST API, get each part routed to CNC, sheet metal, molding or harness shops, compare live quotes and place approved orders.

The Make API takes a folder of CAD files to real quotes in four calls. Maglev reads each part's geometry, decides how it should be made and sends it to a shop that makes it:

| Process | Shops asked | Quote |
| - | - | - |
| CNC machining | [Make Parts Now](https://makepartsnow.com), plus Justway, PCBWay, SendCutSend, Protolabs, Craftcloud, RivCut, Weerg and others through the [Agentic Fabrication Network](https://agenticfabricationnetwork.ai) | Live prices and dates, one offer per shop |
| Sheet metal | [RMFG](https://www.rmfg.com), plus SendCutSend, Justway, PCBWay, Protolabs and others through the Agentic Fabrication Network | Live prices and dates, one offer per shop |
| Injection molding | [SSG MFG](https://ssgmfg.com) | Budgetary estimate including tooling |
| Wire harness | [MiniProto](https://www.miniproto.com) | Live price |

Which shops answer depends on the part; a shop that can't make it simply doesn't return an offer.

Agents that speak MCP get the same four steps as tools at `https://trymaglev.com/mcp` (see [MCP server](/docs/mcp/overview)). This page uses plain HTTP.

## 1. Get a key

Log in or sign up at [trymaglev.com/dashboard](https://trymaglev.com/dashboard#keys), open **API keys** in the sidebar, and choose **Create secret key**. Name the key; it is shown once, with a Copy button, and the dashboard checks it against `GET /api/v1/me` right away. Keep it in your environment or a secret manager:

```bash theme={null}
export MAGLEV_KEY=mgl_…
```

Keys from **Connect agent** (saved in `~/.maglev/token`) work the same way. Check a key with:

```bash theme={null}
curl https://trymaglev.com/api/v1/me -H "Authorization: Bearer $MAGLEV_KEY"
```

## 2. Upload each file

Send a STEP file (`.step`, `.stp`) or a wire harness spec (`.json`), up to 20 MB each. Files are kept for 7 days.

```bash theme={null}
curl https://trymaglev.com/api/v1/files \
  -H "Authorization: Bearer $MAGLEV_KEY" \
  -F "file=@base_bracket.step"
```

```json theme={null}
{
 "file_id": "f_8c41…",
 "name": "base_bracket.step",
 "bbox_mm": [80, 40, 40],
 "suggested_process": "sheet_metal",
 "route_reason": "bent sheet: 2 mm thick, R2 inside bend radius"
}
```

The route comes from the part's own geometry, not its file name. See [how routing works](#how-routing-works).

## 3. Check that each part can be made

```bash theme={null}
curl https://trymaglev.com/api/v1/check \
  -H "Authorization: Bearer $MAGLEV_KEY" \
  -H "Content-Type: application/json" \
  -d '{"file_ids": ["f_8c41…", "f_2be0…"]}'
```

Each file comes back with its `process`, `shop`, `routed_because` and any `issues`. A `blocker` issue must be fixed before quoting. `ready_to_quote` is `true` when every file is clear.

## 4. Get quotes from every shop

```bash theme={null}
curl https://trymaglev.com/api/v1/quotes \
  -H "Authorization: Bearer $MAGLEV_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: robot-joint-qty10" \
  -d '{"file_ids": ["f_8c41…", "f_2be0…"], "quantity": 10, "sort": "price"}'
```

Every shop that makes each part's process is asked in parallel, and every offer comes back, sorted by your `sort` (`price` or `lead_time`). A four-part request usually answers in 10 to 20 seconds.

```json theme={null}
{
 "request_id": "rq_dd60…",
 "parts": [
  { "file": "joint_housing.step", "process": "cnc_machining",
    "offers": [
     { "quote_id": "mq_…", "shop": { "name": "Justway", "country": "CN", "via": "AFN" }, "price_type": "firm", "total_usd": 226.35, "arrives_by": "2026-11-20" },
     { "quote_id": "mq_…", "shop": { "name": "PCBWay", "country": "CN", "via": "AFN" }, "price_type": "firm", "total_usd": 257.08, "arrives_by": "2026-11-23" },
     { "quote_id": "mq_…", "shop": { "name": "Make Parts Now", "country": "US" }, "price_type": "firm", "total_usd": 543.07, "ships_by": "2026-11-19" }
    ] },
  { "file": "base_bracket.step", "process": "sheet_metal",
    "offers": [
     { "quote_id": "mq_…", "shop": { "name": "SendCutSend", "country": "US", "via": "AFN" }, "price_type": "firm", "total_usd": 40.5, "arrives_by": "2026-11-16" },
     { "quote_id": "mq_…", "shop": { "name": "RMFG", "country": "US" }, "price_type": "firm", "total_usd": 77, "ships_by": "2026-11-15" }
    ] }
 ]
}
```

These are real prices from the robot-joint example on November 9, 2026 (shortened; that run returned 12 CNC offers and 7 sheet-metal offers). Show the person every offer; Maglev doesn't pick a winner. Molding totals include the one-time mold cost, listed in `one_time_costs`. Field details are in the [reference](/docs/api-reference/make-api).

## 5. Order, with a person's approval

Ordering takes two calls, so nothing is ever bought without a person seeing the exact total.

First, ask for the final total. Nothing is charged:

```bash theme={null}
curl https://trymaglev.com/api/v1/orders \
  -H "Authorization: Bearer $MAGLEV_KEY" \
  -H "Content-Type: application/json" \
  -d '{"quote_id": "mq_8e95…"}'
```

```json theme={null}
{ "status": "needs_approval", "charged": false, "final_total_usd": 77, "ask_human": "Charge $77 to Maglev's card on file at RMFG for 10 × base_bracket.step?" }
```

Show `ask_human` to a person. When they approve, send the same total back with a note saying who approved it:

```bash theme={null}
curl https://trymaglev.com/api/v1/orders \
  -H "Authorization: Bearer $MAGLEV_KEY" \
  -H "Content-Type: application/json" \
  -d '{"quote_id": "mq_8e95…", "approved_total_usd": 77, "approval_note": "Approved by Ada in chat, 2026-11-09"}'
```

If the total changed, the call returns `needs_approval` again with the new total. Ordering the same quote twice returns the first order.

What happens next depends on the shop:

| Shop | After approval |
| - | - |
| RMFG | Paid with Maglev's card on file. Returns `ordered` with an order link |
| Make Parts Now | Returns `checkout_created` with a checkout link for the ship-to address and payment |
| MiniProto | Returns `checkout_created` with the saved design to pay for |
| SSG MFG | Sends the request for quote. Returns `rfq_sent`; their team replies with a firm quote |

## How routing works

Maglev reads the surfaces in the STEP file:

* **Sheet metal:** bends (two cylinders on one axis whose radii differ by a sheet thickness) and the same thickness everywhere.
* **Injection molding:** drafted walls, meaning tapered side faces on a part with no bends.
* **CNC machining:** any other solid, such as blocks with pockets, bores and holes.

Harness specs (`.json`) go to wire harness. If the geometry can't decide, the file name is used. To choose yourself, pass `processes` to `check` or `quotes`:

```json theme={null}
{ "file_ids": ["f_8c41…"], "processes": { "f_8c41…": "cnc_machining" } }
```

## Track everything

`GET /api/v1/requests` lists your requests, newest first, each part with every offer and its order status. The same history is on your [dashboard](https://trymaglev.com/dashboard), where each part's offers are laid out in a comparison table.

## Teams

On the dashboard, **Members → Invite people** adds teammates to your workspace by email. Everyone in a workspace sees the same requests, offers, orders and usage. API keys stay personal: each person creates their own, and a revoked key affects only its owner.

The full list of endpoints and fields is in the [Make API reference](/docs/api-reference/make-api).


# Maglev: connect your AI agent to manufacturing
Source: https://trymaglev.com/docs/index

Maglev lets an AI agent turn CAD files into real parts: manufacturability checks, quotes from many shops and human-approved orders, over MCP or REST.

Maglev connects the agent you already use, such as Claude Code or Codex, to real manufacturers. Point it at a folder of STEP files or a wire-harness spec and it checks each part, routes it to the right process, asks every shop that makes that process for a quote, and orders only after a person approves the exact total.

You can use Maglev two ways:

* **MCP server** at `https://trymaglev.com/mcp`, for agents. One URL gives your agent 16 tools: four for making custom parts and twelve for the off-the-shelf parts catalog.
* **REST API** at `https://trymaglev.com/api/v1`, for your own code. The same four steps (upload, check, quote, order) as plain HTTP.

> [card] [Quickstart](/docs/quickstart)
>
> Connect Claude Code or Codex and get your first quotes from a STEP file.

> [card] [MCP server](/docs/mcp/overview)
>
> The endpoint, how to connect any MCP client, and every tool it exposes.

> [card] [Make parts from CAD](/docs/how-to/make-parts-from-cad)
>
> Upload, check, quote and order with the REST API, step by step.

> [card] [Make API reference](/docs/api-reference/make-api)
>
> Endpoints, fields, order statuses, idempotency and errors.

## What Maglev makes

| Process | Shops asked | Quote |
| - | - | - |
| CNC machining | Make Parts Now, plus Justway, PCBWay, SendCutSend, Protolabs, Craftcloud, RivCut, Weerg and others through the Agentic Fabrication Network | Live prices and dates, one offer per shop |
| Sheet metal | RMFG, plus SendCutSend, Justway, PCBWay, Protolabs and others through the Agentic Fabrication Network | Live prices and dates, one offer per shop |
| Injection molding | SSG MFG | Budgetary estimate including tooling |
| Wire harness | MiniProto | Live price |

Maglev reads each part's geometry to choose the process, shows you every offer, and never picks a winner for you.

## Open data, no key needed

> [card] [Parts catalog](/docs/open-data/parts-catalog)
>
> 688 compute modules, motors, robot actuators and drone parts with dated prices, origin, NDAA status and landed cost.

> [card] [Manufacturer directory](/docs/open-data/manufacturer-directory)
>
> 1,228 custom-parts manufacturers worldwide, each with sources and a date.

## For agents

Every page of these docs is also available as Markdown: add `.md` to its URL. The full index is at [`/docs/llms.txt`](https://trymaglev.com/docs/llms.txt). See [Agent resources](/docs/agent-resources) for everything an agent can read or connect to.


# Maglev MCP server for AI agents
Source: https://trymaglev.com/docs/mcp/overview

Connect any MCP client to https://trymaglev.com/mcp over streamable HTTP: 16 tools for custom-part quotes and orders plus a searchable hardware parts catalog.

The Maglev MCP server lets any agent that speaks the Model Context Protocol make custom parts and search off-the-shelf hardware. It runs at one URL over streamable HTTP, so there is nothing to install.

| | |
| - | - |
| Endpoint | `https://trymaglev.com/mcp` |
| Transport | Streamable HTTP (JSON-RPC over POST) |
| Auth | `Authorization: Bearer mgl_…` for Make tools. Parts tools work without a key |
| Tools | 16: four Make tools and twelve Parts tools. See [all tools](/docs/mcp/tools) |

## Connect a client

> [tab] Claude Code
>
> ```bash theme={null}
> claude mcp add --scope user --transport http maglev https://trymaglev.com/mcp \
>   --header "Authorization: Bearer YOUR_MAGLEV_KEY"
> ```
>
> Or run the one-command setup in the [quickstart](/docs/quickstart), which signs you in and adds this for you.

> [tab] Codex
>
> Add to `~/.codex/config.toml`:
>
> ```toml theme={null}
> [mcp_servers.maglev]
> url = "https://trymaglev.com/mcp"
> http_headers = { Authorization = "Bearer YOUR_MAGLEV_KEY" }
> ```

> [tab] Any HTTP client
>
> Send JSON-RPC to the endpoint. For example, list the tools:
>
> ```bash theme={null}
> curl -X POST https://trymaglev.com/mcp \
>   -H "Content-Type: application/json" \
>   -H "Accept: application/json, text/event-stream" \
>   -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
> ```

Get a key from the [dashboard](https://trymaglev.com/dashboard#keys). See [Authentication](/docs/authentication).

## The make flow

For custom parts from CAD, an agent calls the four Make tools in order:

**1. make\_start**

Takes the local file names and returns one upload command per file for the agent to run with its shell tool, plus how each file will be routed.

**2. check\_manufacturability**

Runs each file through its manufacturer's design check in parallel. Returns blockers and warnings per file and an overall `ready_to_quote`.

**3. get\_quotes**

Asks every shop that makes each file's process, in parallel. Returns every offer in one shape. Show them all to the person; do not pick a winner.

**4. place\_order**

First call without `approved_total_usd` returns the final total and charges nothing. Call again with the exact total only after the person approves it.

> [!WARNING]
>
> `place_order` with an approved total can become a real paid order. For sheet metal at RMFG it is charged to Maglev's card on file. Always show the person the exact total first and quote their approval in `approval_note`.

The same flow over HTTP is in [Make parts from CAD](/docs/how-to/make-parts-from-cad).


# Maglev MCP tools reference
Source: https://trymaglev.com/docs/mcp/tools

All 16 Maglev MCP tools: make_start, check_manufacturability, get_quotes and place_order for custom parts, plus search, matching, landed cost and joint planning.

The Maglev MCP server at `https://trymaglev.com/mcp` exposes 16 tools. The four Make tools need a [Maglev key](/docs/authentication); the twelve Parts tools work without one. Your client reads each tool's full input schema with `tools/list`; this page summarizes them.

## Make tools (key required)

| Tool | What it does | Required arguments |
| - | - | - |
| `make_start` | Start here for CAD (STEP) or wire-harness (JSON) files. Returns one shell command per file that uploads it, and how each will be routed: CNC machining, sheet metal, injection molding or wire harness | `file_names` |
| `check_manufacturability` | Runs each uploaded file through its manufacturer's design-for-manufacturing check in parallel. Returns ok, blockers and warnings per file, and `ready_to_quote` | `file_ids` |
| `get_quotes` | Quotes every file from every shop that makes its process, in parallel. Returns `parts[]`, each with `offers[]` (shop, `price_type` firm or budgetary, `total_usd`, `one_time_costs`, `lead_time_days`, `ships_by`, `quote_id`) | `file_ids`, `quantity` |
| `place_order` | Without `approved_total_usd`, returns the final total and charges nothing. With the exact total a person approved and `approval_note` in their words, places the order | `quote_id` |

`check_manufacturability` and `get_quotes` also accept:

* `processes`: per-file process override, `{ file_id: process }`.
* `options`: per-file options, `{ file_id: { material, finish, tolerance_mm, wall_mm, draft_deg, speed } }`. CNC finishes are `standard`, `anodized`, `polished`, `bead_blasted`; sheet metal finishes are `as_cut`, `deburred`, `anodized`, `powder_coat`. Each offer reports `finish_applied`.

`get_quotes` takes `sort`: `price` (default) or `lead_time`.

What happens after an approved order depends on the shop: sheet metal at RMFG is charged to Maglev's card on file and becomes a production order; CNC and harness return the shop's checkout link; molding sends the request for quote to SSG MFG for a firm quote.

## Parts tools (no key)

| Tool | What it does | Required arguments |
| - | - | - |
| `search_parts` | Search the catalog (compute modules, motors and drivers, robot actuators, drone parts) by part number, brand or spec words such as "48V" or "Orin NX". Filter by origin `lens`, `ndaa_only`, `category` | none |
| `list_categories` | Categories and subcategories with part counts and the spec columns each compares on | none |
| `requirement_keys` | The requirement keys a subcategory accepts for `match_requirements`, with units and catalog ranges | `subcategory` |
| `match_requirements` | Rank every part in a subcategory against your numbers. Each result says per requirement whether it meets, is close (within 15%), misses or is unknown, and names the requirement blocking the most options | `subcategory`, `requirements` |
| `get_part` | Full record for one part: specs, dated prices with sources, maker, origin, HTS, NDAA, Blue UAS, FCC, equivalents and compatible parts | `id` |
| `compare_parts` | Side by side comparison of 2 to 10 parts: shared specs, price at a quantity, origin, NDAA | `ids` |
| `find_equivalents` | Drop-in or near equivalents from other makers, optionally by origin lens, plus parts commonly paired with it | `id` |
| `landed_cost` | US landed cost estimate: goods value, duty stack for the origin (each program with a source), merchandise processing fee and freight. An estimate, not customs advice | `id` |
| `plan_joint` | Plan a robot joint from peak torque, speed, bus voltage, mass budget and quantity. Returns complete actuators that meet the targets and joints built from motor, reducer, driver and encoder, with the math shown | `peak_torque_nm`, `voltage_v` |
| `get_test_protocol` | Nine bench tests for a robot joint actuator in run order, and three priced bench kits (starter, serious, lab) | none |
| `check_test_result` | Check a bench test result against the result format and the part's datasheet (peak and continuous torque, backlash, Kv, Kt). Nothing is stored | `result` |
| `build_rfq` | Build a request for Maglev to buy listed parts, price unlisted ones or make custom versions. Returns the request and a ready-to-send email. Nothing is sent | `items` |

Origin `lens` values: `any`, `cn` (China including Hong Kong), `not-cn`, `us`, `usmca` (US, Canada, Mexico), `allied`.

> [!NOTE]
>
> Catalog prices carry a source and the date seen. A value that is not confirmed is `unknown`; agents should report it as unknown rather than guess.


# Custom-parts manufacturer directory API
Source: https://trymaglev.com/docs/open-data/manufacturer-directory

Free JSON directory of 1,228 custom-parts manufacturers worldwide: CNC, sheet metal, molding, casting, PCB and PCBA, harnesses, 3D printing, with sources.

[Maglev Make](https://trymaglev.com/make/) is an open directory of 1,228 manufacturers for custom parts worldwide, grouped by process: machining, sheet metal, molding, casting, PCB fabrication and assembly, wire harnesses, 3D printing and finishing. Every record lists its sources and the date it was checked; a field that is not confirmed says `unknown`. No key is needed.

Base URL: `https://trymaglev.com/make`

## Endpoints

| Endpoint | What it returns |
| - | - |
| `/api/index.json` | Every process with its shop count and a link to its list |
| `/api/manufacturers.json` | All manufacturers in one request |
| `/api/process/{process}.json` | Manufacturers for one process, such as `cnc-milling` or `cnc-5axis` |
| `/api/f/{id}.json` | One manufacturer |
| `/api/search-index.json` | Compact index for client-side search |

Every directory page also has a JSON twin, linked from the page with `rel="alternate"`.

## Example

```bash theme={null}
curl https://trymaglev.com/make/api/f/mfg-4a-001.json
```

A record includes the company's name, country, region and city, website, processes, specialty, and, when known, capabilities, materials, tolerance, maximum part size, certifications, minimum order and lead times.

## Get quotes from these shops

To get live quotes for a CAD file, use the [make flow](/docs/how-to/make-parts-from-cad) or the Make tools on the [MCP server](/docs/mcp/overview). Agent-readable summary: [trymaglev.com/make/llms.txt](https://trymaglev.com/make/llms.txt).


# Hardware parts catalog API: actuators, motors, Jetson
Source: https://trymaglev.com/docs/open-data/parts-catalog

Free JSON API for 688 hardware parts: Jetson and compute modules, motors, robot actuators and drone parts, with sourced prices, origin, NDAA status and landed cost.

[Maglev Parts](https://trymaglev.com/parts/) is an open catalog of 688 off-the-shelf hardware parts for hardware founders: compute modules, motors and motor drivers, robot actuators and transmissions, drone components and test equipment. Every part carries sources, dated prices, country of origin, NDAA and Blue UAS status, and a landed-cost estimate. No key or login is needed, and CORS is open.

Base URL: `https://trymaglev.com/parts`

## Endpoints

| Endpoint | What it returns |
| - | - |
| `/api/parts.json` | The whole catalog in one request |
| `/api/parts/{id}.json` | One part |
| `/api/categories/{category}.json` | One category: `compute-modules`, `motors`, `actuators`, `drone`, `test-equipment` |
| `/api/search?q={query}&lens={lens}&ndaa={0\|1}` | Search by part number, brand or spec words |
| `/api/route?sub={subcategory}&{key}={min}-{max}` | Rank a subcategory against your requirements. Keys are listed at `/api/find/index.json` |
| `/api/plan?peak_torque_nm=&voltage_v=` | Plan a robot joint. Also takes `speed_rpm`, `max_mass_g`, `qty` |
| `/api/landed?id={id}&qty={n}&origin={ISO2}&freight={usd}` | US landed cost estimate |
| `/api/trade.json` | Duty data used for landed cost |
| `/api/test/joint-actuator.json` | Nine bench tests for a joint actuator and three priced bench kits |
| `/p/{id}/index.md` | One part as Markdown |
| `/openapi.json` | OpenAPI description of the catalog API |

`lens` filters by where a part is made: `any`, `cn` (China including Hong Kong), `not-cn`, `us`, `usmca` (US, Canada, Mexico), `allied`.

## Examples

Find Orin NX carriers not made in China:

```bash theme={null}
curl "https://trymaglev.com/parts/api/search?q=orin%20nx&lens=not-cn"
```

Rank joint actuators with at least 60 N·m peak torque and under 1 kg:

```bash theme={null}
curl "https://trymaglev.com/parts/api/route?sub=joint-actuators&peak_torque_nm=60-&mass_g=-1000"
```

Plan a 40 N·m joint on a 48 V bus:

```bash theme={null}
curl "https://trymaglev.com/parts/api/plan?peak_torque_nm=40&voltage_v=48"
```

## Data you can trust

Every price has a source URL and the date it was seen. Fields that are not confirmed say `unknown`. Each record has a confidence: `VERIFIED` (from the maker), `REPORTED` (a credible third party) or `UNVERIFIED` (a single weak source).

## Use it from an agent

The same catalog is available as MCP tools at `https://trymaglev.com/mcp`, with no key: see [Parts tools](/docs/mcp/tools#parts-tools-no-key). Agent-readable summaries are at [trymaglev.com/parts/llms.txt](https://trymaglev.com/parts/llms.txt) and the full catalog as Markdown at [llms-full.txt](https://trymaglev.com/parts/llms-full.txt).

To buy listed parts, price unlisted ones or ask for custom versions, use the `build_rfq` tool or the [order pad](https://trymaglev.com/parts/pad/). Maglev returns one price for the whole request, fixed before you commit.


# Quickstart: get manufacturing quotes from your AI agent
Source: https://trymaglev.com/docs/quickstart

Connect Claude Code or Codex to the Maglev MCP server, then ask your agent to quote a folder of STEP files from several manufacturers in minutes.

This quickstart connects your coding agent to the Maglev MCP server and gets real quotes for a CAD part. You need a Maglev account (free to create) and Claude Code or Codex.

**1. Connect your agent**

> [tab] Claude Code (one command)
>
> Run this in a terminal. It opens a browser to sign in or sign up, saves a key to `~/.maglev/token`, and adds Maglev to Claude Code:
>
> ```bash theme={null}
> curl -fsSL https://trymaglev.com/connect.sh -o connect.sh && sh connect.sh
> ```
>
> If it prints `MAGLEV WAITING`, finish signing in and run the same command again. It resumes the same sign-in.

> [tab] Claude Code (with a key)
>
> Create a key on the [dashboard](https://trymaglev.com/dashboard#keys) (**API keys**, then **Create secret key**), then run:
>
> ```bash theme={null}
> claude mcp add --scope user --transport http maglev https://trymaglev.com/mcp \
>   --header "Authorization: Bearer YOUR_MAGLEV_KEY"
> ```

> [tab] Codex
>
> Create a key on the [dashboard](https://trymaglev.com/dashboard#keys), then add Maglev to `~/.codex/config.toml`:
>
> ```toml theme={null}
> [mcp_servers.maglev]
> url = "https://trymaglev.com/mcp"
> http_headers = { Authorization = "Bearer YOUR_MAGLEV_KEY" }
> ```
>
> If you added Maglev before, delete the old `[mcp_servers.maglev]` block first.

**2. Open your agent in a folder with CAD files**

Maglev accepts STEP files (`.step`, `.stp`) and wire-harness specs (`.json`), up to 20 MB each.

```bash theme={null}
cd my-robot-parts
claude
```

**3. Ask for quotes**

Tell the agent what you want, for example:

> Get quotes for 10 of each part in this folder.

The agent calls `make_start` to upload the files, `check_manufacturability` to run each shop's design check, and `get_quotes` to ask every shop that makes each part's process. A four-part request usually answers in 10 to 20 seconds. The agent shows you every offer.

**4. Order, only if you approve**

If you want to order, the agent calls `place_order` first without a total. That returns the final total and charges nothing. The order goes through only after you approve that exact amount.

> [!TIP]
>
> Your requests, offers and orders also appear on the [dashboard](https://trymaglev.com/dashboard), with each part's offers side by side.

## Next steps

> [card] [MCP tools](/docs/mcp/tools)
>
> What each of the 16 tools does and the arguments it takes.

> [card] [Use the REST API](/docs/how-to/make-parts-from-cad)
>
> The same flow over HTTP, with request and response examples.