# Load Cell API
> Load-cell (weighing-transducer) maths as an API, computed locally and deterministically. The output endpoint computes the bridge output voltage a strain-gauge load cell produces under a given load, Vout = (load/capacity)·sensitivity·excitation, where the full-scale output FSO = sensitivity(mV/V)·excitation(V) is reached at the rated capacity — it returns the output in millivolts, the equivalent mV/V at that load and the capacity utilization, and flags overload. The load endpoint inverts this to recover the applied load from a measured bridge output, load = (Vout/FSO)·capacity. The array endpoint sizes a multi-cell weighing platform: from the number of identical cells, the per-cell capacity and the live and dead (tare) load it returns the evenly distributed per-cell load, its output and utilization and the total system capacity, so cells can be chosen to stay under capacity in the worst case. Sensitivity is in mV/V, excitation in volts (default 10), output in millivolts; load and capacity share any consistent unit. Everything is computed locally and deterministically, so it is instant and private. Ideal for industrial-weighing, scale, force-measurement, silo and process-control app developers, load-cell sizing and calibration tools, and instrumentation education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is load-cell transducer output; for the underlying Wheatstone-bridge and strain maths use a Wheatstone-bridge 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/loadcell-api/..."
```

## Pricing
- **Free** (Free) — 2,200 calls/Mo, 2 req/s
- **Starter** ($10/Mo) — 46,000 calls/Mo, 6 req/s
- **Pro** ($24/Mo) — 270,000 calls/Mo, 15 req/s
- **Mega** ($74/Mo) — 1,650,000 calls/Mo, 40 req/s

## Endpoints

### LoadCell

#### `GET /v1/array` — Multi-cell array

**Parameters:**
- `cells` (query, required, string) — Number of cells Example: `4`
- `rated_capacity` (query, required, string) — Per-cell capacity Example: `500`
- `sensitivity` (query, required, string) — Sensitivity (mV/V) Example: `3`
- `excitation` (query, optional, string) — Excitation (V) Example: `10`
- `total_load` (query, required, string) — Live load on platform Example: `1200`
- `dead_load` (query, optional, string) — Dead/tare load Example: `200`

**Example:**
```bash
curl -H "x-oanor-key: $KEY" \
  "https://api.oanor.com/loadcell-api/v1/array?cells=4&rated_capacity=500&sensitivity=3&excitation=10&total_load=1200&dead_load=200"
```

**Response:**
```json
{
    "data": {
        "note": "Evenly distributed: each cell carries (total_load + dead_load)/n. System capacity = n · per-cell capacity. Size cells so the worst-case per-cell load (including dead load) stays under capacity.",
        "inputs": {
            "cells": 4,
            "dead_load": 200,
            "total_load": 1200,
            "excitation_v": 10,
            "rated_capacity": 500,
            "sensitivity_mv_v": 3
        },
        "overload": false,
        "per_cell_load": 350,
        "system_capacity": 2000,
        "per_cell_output_mv": 21,
        "per_cell_utilization_pct": 70
    },
    "meta": {
        "timestamp": "2026-06-05T11:30:37.296Z",
        "request_id": "837f1188-6611-4471-80bd-df8fa318bff7"
    },
    "status": "ok",
    "message": "Multi-cell array",
    "success": true
}
```

#### `GET /v1/load` — Load from output

**Parameters:**
- `output_mv` (query, required, string) — Measured output (mV) Example: `10`
- `rated_capacity` (query, required, string) — Rated capacity Example: `50`
- `sensitivity` (query, required, string) — Sensitivity (mV/V) Example: `2`
- `excitation` (query, optional, string) — Excitation voltage (V) Example: `10`

**Example:**
```bash
curl -H "x-oanor-key: $KEY" \
  "https://api.oanor.com/loadcell-api/v1/load?output_mv=10&rated_capacity=50&sensitivity=2&excitation=10"
```

**Response:**
```json
{
    "data": {
        "load": 25,
        "note": "Load = (Vout / (sensitivity·excitation)) · capacity. The measured bridge output scales linearly with applied load.",
        "inputs": {
            "output_mv": 10,
            "excitation_v": 10,
            "rated_capacity": 50,
            "sensitivity_mv_v": 2
        },
        "utilization_pct": 50,
        "full_scale_output_mv": 20
    },
    "meta": {
        "timestamp": "2026-06-05T11:30:37.415Z",
        "request_id": "91eba123-bec4-415c-bd6f-c10406ffe61a"
    },
    "status": "ok",
    "message": "Load from output",
    "success": true
}
```

#### `GET /v1/output` — Bridge output

**Parameters:**
- `load` (query, required, string) — Applied load Example: `25`
- `rated_capacity` (query, required, string) — Rated capacity Example: `50`
- `sensitivity` (query, required, string) — Sensitivity (mV/V) Example: `2`
- `excitation` (query, optional, string) — Excitation voltage (V) Example: `10`

**Example:**
```bash
curl -H "x-oanor-key: $KEY" \
  "https://api.oanor.com/loadcell-api/v1/output?load=25&rated_capacity=50&sensitivity=2&excitation=10"
```

**Response:**
```json
{
    "data": {
        "note": "Output(mV) = (load/capacity)·sensitivity·excitation. Full-scale output = sensitivity·excitation occurs at the rated capacity; staying under 100 % utilization avoids overload.",
        "inputs": {
            "load": 25,
            "excitation_v": 10,
            "rated_capacity": 50,
            "sensitivity_mv_v": 2
        },
        "output_v": 0.01,
        "overload": false,
        "output_mv": 10,
        "utilization_pct": 50,
        "output_at_load_mv_v": 1,
        "full_scale_output_mv": 20
    },
    "meta": {
        "timestamp": "2026-06-05T11:30:37.489Z",
        "request_id": "e6f925b2-b1d2-483e-85a9-68d72728ecf8"
    },
    "status": "ok",
    "message": "Output voltage",
    "success": true
}
```

### Meta

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

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

**Response:**
```json
{
    "data": {
        "notes": "Sensitivity in mV/V, excitation in V (default 10), output in mV. Load and capacity share any consistent unit (kg, N, lb). Utilization is load/capacity.",
        "service": "loadcell-api",
        "formulae": {
            "load": "load = (Vout / FSO) · capacity",
            "output": "Vout = (load/capacity) · FSO",
            "full_scale": "FSO(mV) = sensitivity(mV/V) · excitation(V)"
        },
        "endpoints": {
            "GET /v1/load": "Applied load from a measured bridge output.",
            "GET /v1/meta": "This document.",
            "GET /v1/array": "Per-cell load, output and utilization for N cells under one platform.",
            "GET /v1/output": "Bridge output (mV) and utilization from an applied load."
        },
        "description": "Load-cell (weighing-transducer) calculator: bridge output voltage from applied load, load from a measured output, and multi-cell platform arrays — using the rated capacity, sensitivity (mV/V) and excitation voltage."
    },
    "meta": {
        "timestamp": "2026-06-05T11:30:37.602Z",
        "request_id": "90d9433a-9ac7-4e29-86e1-ba6a246ae935"
    },
    "status": "ok",
    "message": "Meta",
    "success": true
}
```


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