# Elevator Traction API
> Traction-elevator engineering maths as an API, computed locally and deterministically — the counterweight, hoist-motor and rope-traction numbers a lift engineer or building-services designer sizes a passenger elevator with. The counterweight endpoint gives the balancing mass = the empty car plus a fraction of the rated load (the overbalance, typically 40–50 %, 45 % common), so a 1,000 kg car rated for 1,000 kg uses a 1,450 kg counterweight — the car and weight balance near half load and the machine is sized for the worst-case imbalance, not the full load. The motor-power endpoint uses that: because the counterweight cancels most of the car, the motor only lifts the out-of-balance load = rated load × (1 − overbalance), so power = that × g × speed ÷ efficiency (~65–75 % geared) — a 1,000 kg lift at 1.5 m/s needs only about 11–12 kW, half what a counterweight-less hoist would draw. The traction-ratio endpoint checks the friction grip: a traction elevator moves the ropes by friction over the sheave, so the available traction (e^(μθ), the capstan equation) must beat the T1/T2 tension ratio at both worst cases — a full car at the bottom and an empty car at the top — and it returns the governing ratio. Everything is computed locally and deterministically, so it is instant and private. Ideal for lift-design and building-services tools, vertical-transport and MEP utilities, and engineering calculators. Pure local computation — no key, no third-party service, instant. Sizing estimates — follow the lift code and maker data. 3 compute endpoints. For block-and-tackle use a pulley API; for capstan friction a capstan API.

## Authentication
All requests require your oanor API key in the `x-oanor-key` header. Get one at https://www.oanor.com/developer/keys.

```bash
curl -H "x-oanor-key: oanor_live_…" "https://api.oanor.com/elevator-api/..."
```

## Pricing
- **Free** (Free) — 4,650 calls/Mo, 2 req/s
- **Starter** ($13/Mo) — 48,500 calls/Mo, 6 req/s
- **Pro** ($41/Mo) — 207,000 calls/Mo, 15 req/s
- **Mega** ($127/Mo) — 1,105,000 calls/Mo, 40 req/s

## Endpoints

### Elevator

#### `GET /v1/counterweight` — Counterweight from car and load

**Parameters:**
- `car_weight_kg` (query, required, string) — Empty car weight (kg) Example: `1000`
- `rated_load_kg` (query, required, string) — Rated load (kg) Example: `1000`
- `balance_pct` (query, optional, string) — Overbalance % (default 45) Example: `45`

**Example:**
```bash
curl -H "x-oanor-key: $KEY" \
  "https://api.oanor.com/elevator-api/v1/counterweight?car_weight_kg=1000&rated_load_kg=1000&balance_pct=45"
```

**Response:**
```json
{
    "data": {
        "note": "The counterweight is set to the empty car plus a fraction of the rated load — the overbalance, typically 40–50 % (45 % is common). At that load the car and counterweight balance and the motor barely works; lighter or heavier loads tip the balance one way and the motor makes up the difference. So a 1,000 kg car rated for 1,000 kg at 45 % overbalance uses a 1,450 kg counterweight, and the machine is sized for the worst-case imbalance, not the full load.",
        "inputs": {
            "balance_pct": 45,
            "car_weight_kg": 1000,
            "rated_load_kg": 1000
        },
        "overbalance_pct": 45,
        "counterweight_kg": 1450
    },
    "meta": {
        "timestamp": "2026-06-07T08:17:57.726Z",
        "request_id": "e26e6358-9715-4f6d-a38d-c795b253e640"
    },
    "status": "ok",
    "message": "Counterweight",
    "success": true
}
```

#### `GET /v1/motor-power` — Hoist-motor power at full load

**Parameters:**
- `rated_load_kg` (query, required, string) — Rated load (kg) Example: `1000`
- `speed_mps` (query, required, string) — Car speed (m/s) Example: `1.5`
- `balance_pct` (query, optional, string) — Overbalance % (default 45) Example: `45`
- `efficiency_pct` (query, optional, string) — Drive efficiency % (default 70) Example: `70`

**Example:**
```bash
curl -H "x-oanor-key: $KEY" \
  "https://api.oanor.com/elevator-api/v1/motor-power?rated_load_kg=1000&speed_mps=1.5&balance_pct=45&efficiency_pct=70"
```

**Response:**
```json
{
    "data": {
        "note": "Because the counterweight cancels most of the car, the hoist motor only lifts the out-of-balance load = rated load × (1 − overbalance). Power = that mass × g × speed ÷ efficiency (~65–75 % for a geared machine, higher gearless). A 1,000 kg lift at 45 % overbalance and 1.5 m/s needs the motor to lift ~550 kg, about 11–12 kW — far less than the ~21 kW a hoist without a counterweight would need.",
        "inputs": {
            "speed_mps": 1.5,
            "balance_pct": 45,
            "rated_load_kg": 1000,
            "efficiency_pct": 70
        },
        "motor_power_hp": 15.5,
        "motor_power_kw": 11.56,
        "out_of_balance_load_kg": 550
    },
    "meta": {
        "timestamp": "2026-06-07T08:17:57.839Z",
        "request_id": "c000e185-ef64-460c-bcfe-724e78f09aad"
    },
    "status": "ok",
    "message": "Motor power",
    "success": true
}
```

#### `GET /v1/traction-ratio` — Rope-traction T1/T2 ratio

**Parameters:**
- `car_weight_kg` (query, required, string) — Empty car weight (kg) Example: `1000`
- `counterweight_kg` (query, required, string) — Counterweight (kg) Example: `1450`
- `rated_load_kg` (query, required, string) — Rated load (kg) Example: `1000`

**Example:**
```bash
curl -H "x-oanor-key: $KEY" \
  "https://api.oanor.com/elevator-api/v1/traction-ratio?car_weight_kg=1000&counterweight_kg=1450&rated_load_kg=1000"
```

**Response:**
```json
{
    "data": {
        "note": "Traction elevators move the ropes by friction over the sheave, so the heavier side cannot out-pull the grip: the available traction (e^(μθ), the capstan equation) must exceed the T1/T2 tension ratio in both worst cases — a full car at the bottom (car side heaviest) and an empty car at the top (counterweight side heaviest). The governing ratio is the larger; keep the sheave groove friction and wrap angle above it, or the ropes slip.",
        "inputs": {
            "car_weight_kg": 1000,
            "rated_load_kg": 1000,
            "counterweight_kg": 1450
        },
        "governing_ratio": 1.45,
        "ratio_empty_car": 1.45,
        "ratio_full_load": 1.379
    },
    "meta": {
        "timestamp": "2026-06-07T08:17:57.919Z",
        "request_id": "1e9d4fc5-b7ad-4b33-854e-e65102acbc0c"
    },
    "status": "ok",
    "message": "Traction ratio",
    "success": true
}
```

### Meta

#### `GET /v1/meta` — Spec

**Example:**
```bash
curl -H "x-oanor-key: $KEY" \
  "https://api.oanor.com/elevator-api/v1/meta"
```

**Response:**
```json
{
    "data": {
        "notes": "SI (kg, m/s, kW). counterweight = car + overbalance·load; motor power = load·(1−overbalance)·g·speed/eff; traction ratio = heavier side / lighter side (compare to e^(μθ)). For block-and-tackle use a pulley API; for capstan friction a capstan API.",
        "service": "elevator-api",
        "endpoints": {
            "GET /v1/meta": "This document.",
            "GET /v1/motor-power": "Hoist-motor power at full load.",
            "GET /v1/counterweight": "Counterweight mass from car, rated load and overbalance.",
            "GET /v1/traction-ratio": "T1/T2 ratio at the two worst cases."
        },
        "description": "Traction-elevator maths: counterweight from car and load, hoist-motor power, and rope-traction T1/T2 ratio."
    },
    "meta": {
        "timestamp": "2026-06-07T08:17:58.005Z",
        "request_id": "8a0897bf-31d9-405f-8cf1-4a29b9102895"
    },
    "status": "ok",
    "message": "Meta",
    "success": true
}
```


---
Marketplace page: https://www.oanor.com/api/elevator-api
OpenAPI spec: https://www.oanor.com/api/elevator-api/openapi.json