Image to DXF API

# 1. Start a conversion (answers at once with its id)
curl https://bevell.app/api/v1/conversions \
  -H "Authorization: Bearer $BEVELL_API_KEY" \
  -H "Idempotency-Key: bracket-0001" \
  -F file=@bracket.png \
  -F mode=lineart \
  -F scale=0.1

# 2. Ask until status is succeeded or failed
curl https://bevell.app/api/v1/conversions/$ID \
  -H "Authorization: Bearer $BEVELL_API_KEY"

# 3. Download the DXF (or files/svg)
curl -o bracket.dxf https://bevell.app/api/v1/conversions/$ID/files/dxf \
  -H "Authorization: Bearer $BEVELL_API_KEY"

import os, time, requests

API = "https://bevell.app/api/v1"
headers = {"Authorization": f"Bearer {os.environ['BEVELL_API_KEY']}"}

with open("bracket.png", "rb") as f:
    r = requests.post(
        f"{API}/conversions",
        headers={**headers, "Idempotency-Key": "bracket-0001"},
        files={"file": f},
        data={"mode": "lineart", "scale": "0.1"},
    )
if not r.ok:
    raise SystemExit(r.json()["error"]["message"])
conversion = r.json()

while conversion["status"] in ("queued", "running"):
    time.sleep(conversion.get("retryAfterMs", 2000) / 1000)
    conversion = requests.get(f"{API}/conversions/{conversion['id']}", headers=headers).json()

if conversion["status"] != "succeeded":
    raise SystemExit(conversion["error"]["message"])

dxf = requests.get(conversion["result"]["files"]["dxf"], headers=headers)
dxf.raise_for_status()
with open("bracket.dxf", "wb") as out:
    out.write(dxf.content)

import { readFile, writeFile } from "node:fs/promises";

const API = "https://bevell.app/api/v1";
const headers = { Authorization: `Bearer ${process.env.BEVELL_API_KEY}` };

const form = new FormData();
form.append("file", new Blob([await readFile("bracket.png")], { type: "image/png" }), "bracket.png");
form.append("mode", "lineart");
form.append("scale", "0.1");

const started = await fetch(`${API}/conversions`, {
  method: "POST",
  headers: { ...headers, "Idempotency-Key": "bracket-0001" },
  body: form,
});
if (!started.ok) throw new Error((await started.json()).error.message);
let conversion = await started.json();

while (conversion.status === "queued" || conversion.status === "running") {
  await new Promise((resolve) => setTimeout(resolve, conversion.retryAfterMs ?? 2000));
  conversion = await (await fetch(`${API}/conversions/${conversion.id}`, { headers })).json();
}
if (conversion.status !== "succeeded") throw new Error(conversion.error.message);

const dxf = await fetch(conversion.result.files.dxf, { headers });
await writeFile("bracket.dxf", Buffer.from(await dxf.arrayBuffer()));

# AI redraw draws at its own size. Fetch its marked drawing,
# measure a feature you know in pixels, then trace it again at that size:
curl -o drawing.png https://bevell.app/api/v1/conversions/$ID/files/drawing \
  -H "Authorization: Bearer $BEVELL_API_KEY"

# A 40 mm hole that measures 320 px across is 40 / 320 = 0.125 mm per pixel
curl https://bevell.app/api/v1/conversions \
  -H "Authorization: Bearer $BEVELL_API_KEY" \
  -F retraceConversionId=$ID \
  -F scale=0.125

# The same upload in another mode, or refined, without sending it again
curl https://bevell.app/api/v1/conversions \
  -H "Authorization: Bearer $BEVELL_API_KEY" \
  -F sourceConversionId=$ID \
  -F mode=default \
  -F refineNote="Leave out the text"

{
  "id": "6c1e…",
  "object": "conversion",
  "status": "succeeded",
  "channel": "api",
  "mode": "lineart",
  "modeReason": null,
  "options": { "scale": 0.1, "scaleFrom": "request", "page": 1, "specialised": "none", "pcbOutline": "board", "readText": false, "refineNote": null },
  "input": { "fileName": "bracket.png", "contentType": "image/png", "bytes": 482113, "sourceConversionId": null, "retraceConversionId": null },
  "metadata": { "order": "1042" },
  "createdAt": "2026-10-15T12:00:00Z",
  "startedAt": "2026-10-15T12:00:02Z",
  "completedAt": "2026-10-15T12:00:41Z",
  "progress": null,
  "error": null,
  "result": {
    "files": { "dxf": "https://bevell.app/api/v1/conversions/6c1e…/files/dxf", "svg": "…", "preview": "…" },
    "stats": { "paths": 212, "page": 1, "pageCount": 1 },
    "refined": null,
    "previewBackground": "dark"
  },
  "retryAfterMs": null
}

{
  "id": "6f0c…",
  "type": "conversion.succeeded",
  "createdAt": "2026-10-15T12:00:00Z",
  "data": { "conversion": { "id": "6c1e…", "status": "succeeded", "metadata": { "order": "1042" }, "result": { "files": { "dxf": "…" } } } }
}

import crypto from "node:crypto";

// rawBody: the request body exactly as it arrived, before any JSON parsing.
// secret: the endpoint's whole secret, whsec_ included.
export function verifyBevellWebhook(rawBody, signatureHeader, secret) {
  const parts = Object.fromEntries(signatureHeader.split(",").map((part) => part.split("=")));
  const t = Number(parts.t);
  if (!t || Math.abs(Date.now() / 1000 - t) > 300) return false;
  const expected = crypto.createHmac("sha256", secret).update(`${t}.${rawBody}`).digest();
  const given = Buffer.from(parts.v1 ?? "", "hex");
  return given.length === expected.length && crypto.timingSafeEqual(given, expected);
}

import hashlib, hmac, time

# raw_body: the request body exactly as it arrived, as bytes.
# secret: the endpoint's whole secret, whsec_ included.
def verify_bevell_webhook(raw_body: bytes, signature_header: str, secret: str) -> bool:
    parts = dict(part.split("=", 1) for part in signature_header.split(","))
    t = int(parts.get("t", "0"))
    if abs(time.time() - t) > 300:
        return False
    expected = hmac.new(secret.encode(), f"{t}.".encode() + raw_body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, parts.get("v1", ""))

{
  "mcpServers": {
    "bevell": {
      "command": "node",
      "args": ["/path/to/bevell-mcp/index.js"],
      "env": { "BEVELL_API_KEY": "bvl_..." }
    }
  }
}