API marketplace

Bézier-curve geometry maths as an API, computed locally and deterministically. The point endpoint evaluates a quadratic (three control points) or cubic (four) Bézier curve at a parameter t between 0 and 1 using de Casteljau's algorithm, returning the point on the curve and the tangent there — its direction vector, angle and speed (the derivative B'(t)). The length endpoint computes the arc length of the curve by fine polyline sampling, together with the straight-line chord length and the axis-aligned bounding box (min and max x and y, width and height). The split endpoint splits the curve at a parameter into two sub-curves and returns the control points of each — the standard de Casteljau subdivision used for trimming and adaptive rendering. Control points are passed as plain x/y coordinates. Everything is computed locally and deterministically, so it is instant and private. Ideal for graphics, CAD, font, animation, game-engine and vector-design app developers, path and curve tools, and computational-geometry education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is Bézier-curve geometry; for animation easing and timing functions use an easing API.

Uptime

100.0%

Latency

174ms

Subs

4,806

Three-phase AC power maths as an API, computed locally and deterministically. The power endpoint solves the three-phase power triangle from the line-to-line voltage, the line current and the power factor — the apparent power S = √3·V_L·I_L in volt-amperes, the real power P = S·cosφ in watts, the reactive power Q = S·sinφ in VAR and the phase angle — or works backwards to find the line current a load draws for a given real power. The wye endpoint gives the star-connection relationships, where the line-to-line voltage is √3 times the phase voltage and the line and phase currents are equal. The delta endpoint gives the delta-connection relationships, where the line and phase voltages are equal and the line current is √3 times the phase current. Supply a line or phase quantity and it returns the rest. Everything is computed locally and deterministically, so it is instant and private. Ideal for electrical, motor, industrial-automation, solar-inverter and building-services app developers, switchboard and motor-sizing tools, and electrical-engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is balanced three-phase power; for the single-phase power triangle use a power-factor API and for voltage drop a voltage-drop API.

Uptime

100.0%

Latency

152ms

Subs

4,965

Complex-number maths as an API, computed locally and deterministically. The arithmetic endpoint adds, subtracts, multiplies or divides two complex numbers z₁ = a + bi and z₂ = c + di, returning the result in both rectangular (a + bi) and polar (modulus ∠ angle) form. The properties endpoint describes a single complex number — its modulus |z| = √(a² + b²), its argument in radians and degrees, its conjugate, its negation, its reciprocal and its polar form. The power endpoint applies De Moivre's theorem, zⁿ = rⁿ(cos nθ + i·sin nθ), to raise a complex number to any real power, and for a positive integer n it also returns all n distinct n-th roots, evenly spaced around the complex plane. The imaginary part defaults to zero, so real inputs work too. Everything is computed locally and deterministically, so it is instant and private. Ideal for engineering, signal-processing, electronics, physics and mathematics app developers, AC-circuit and phasor tools, and STEM education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is complex-number arithmetic; for plane-angle unit conversion use an angle API and for vectors a vector API.

Uptime

100.0%

Latency

164ms

Subs

4,893

Molar-mass and stoichiometry maths as an API, computed locally and deterministically. The molarmass endpoint parses any chemical formula — with parentheses, square brackets and hydrate dots, such as Ca(OH)2, [Fe(CN)6]3 or CuSO4·5H2O — against the IUPAC conventional atomic weights and returns the molar mass in grams per mole, the total atom count and the per-element breakdown with each element's mass contribution and mass percent. The convert endpoint moves between moles, mass in grams and number of molecules for a formula, using n = mass ÷ M = molecules ÷ Nₐ with Avogadro's number. The percent endpoint gives the percent composition by mass and, for a given sample mass, the mass of each element it contains. The formula is parsed locally, so it works for any valid formula, not just compounds in a database, and is instant and private. Ideal for chemistry-education, laboratory, pharmaceutical and science app developers, stoichiometry and lab-prep tools, and STEM teaching. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This computes molar mass from a formula; for compound database lookup use a chemistry API and for element properties an elements API.

Uptime

100.0%

Latency

172ms

Subs

4,161

Special-relativity maths as an API, computed locally and deterministically. The lorentz endpoint computes the Lorentz factor γ = 1/√(1 − β²) from a velocity (in m/s, km/s or as a fraction of the speed of light β), and — given a proper time or a proper length — the dilated time Δt = γ·Δt₀ that a stationary observer measures and the contracted length L = L₀/γ. The energy endpoint computes the rest energy E₀ = mc², the total energy E = γmc², the kinetic energy KE = (γ − 1)mc² and the relativistic momentum p = γmv of a mass moving at a given speed, reporting the energies in both joules and electronvolts. The mass-energy endpoint applies Einstein's E = mc² to convert between mass and energy in either direction, in joules, electronvolts, megaelectronvolts and kilowatt-hours. The speed of light is exactly 299,792,458 m/s. Everything is computed locally and deterministically, so it is instant and private. Ideal for physics-education, simulation, astronomy and science-communication app developers, relativity and particle-physics tools, and STEM teaching. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is special relativity; for everyday SUVAT motion use a kinematics API and for orbital mechanics an orbital API.

Uptime

100.0%

Latency

169ms

Subs

4,281

Rotational and shaft-power maths as an API, computed locally and deterministically. The power endpoint relates mechanical power, torque and rotational speed — give any two of the power, the torque in newton-metres and the speed in rpm and it returns the third using P = T·ω with ω = 2πN/60, reporting the angular velocity and the power in watts, kilowatts, mechanical horsepower and metric horsepower (PS). The angular endpoint converts a rotational speed freely between rpm, radians per second, degrees per second and hertz (revolutions per second), and — given a radius — the tangential speed and centripetal acceleration at the rim. The units endpoint converts power across watts, kilowatts, mechanical horsepower (745.7 W), metric horsepower or PS (735.5 W), foot-pounds per second and BTU per hour. Everything is computed locally and deterministically, so it is instant and private. Ideal for automotive, motor, drivetrain, robotics and machinery app developers, engine and gearbox tools, and mechanical-engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is mechanical shaft power; for bolt tightening torque use a torque API and for electrical power factor a power-factor API.

Uptime

100.0%

Latency

145ms

Subs

4,208

Bernoulli and incompressible-flow maths as an API, computed locally and deterministically. The bernoulli endpoint applies Bernoulli's principle, P + ½ρv² + ρgh = constant along a streamline, taking the pressure, velocity and height at one point and solving the unknown pressure or velocity at a second point, and reporting the total head pressure. The dynamic-pressure endpoint computes the dynamic pressure q = ½ρv² from a velocity, or — the pitot-tube relation — the airspeed v = √(2q/ρ) from a measured dynamic pressure, plus the stagnation (total) pressure when a static pressure is supplied. The venturi endpoint computes the flow rate and inlet and throat velocities of a venturi or contraction from the inlet and throat areas and the pressure drop, Q = Cd·A₂·√(2ΔP/(ρ(1−(A₂/A₁)²))), combining continuity with Bernoulli, with an optional discharge coefficient. Density is taken from a value or a named fluid (air, water, seawater, oil). Everything is computed locally and deterministically, so it is instant and private. Ideal for aerospace, HVAC, plumbing, process and hydraulics app developers, airspeed and flow-meter tools, and fluid-mechanics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is Bernoulli/streamline flow; for pipe friction head loss use a Darcy API and for orifice metering an orifice API.

Uptime

100.0%

Latency

145ms

Subs

3,217

Interpolation maths as an API, computed locally and deterministically. The linear endpoint interpolates between two points, y = y0 + (y1 − y0)·(x − x0)/(x1 − x0), returning the value at a target x (or, given a target y, solving the x that produces it), the parameter t and whether the point lies outside the segment. The table endpoint does piecewise-linear interpolation within a table of (x, y) points supplied as comma-separated lists — it sorts the points, finds the two that bracket your query and interpolates between them, extending the nearest segment and flagging the result when you query outside the data range, ideal for calibration curves and lookup tables. The bilinear endpoint interpolates on a rectangular grid from four corner values, interpolating along x at each y-edge and then along y. Everything is computed locally and deterministically, so it is instant and private, and unlike regression it passes exactly through the supplied points. Ideal for engineering, data-visualisation, gaming, mapping and scientific-computing app developers, lookup-table and calibration tools, and numerical-methods education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is interpolation; for least-squares regression and correlation use a statistics API.

Uptime

100.0%

Latency

175ms

Subs

3,134

Triangle-solving maths as an API, computed locally and deterministically. The solve endpoint solves any triangle from three values — three sides (SSS), two sides and the included angle (SAS), two angles and a side (ASA/AAS), or the ambiguous two-sides-and-a-non-included-angle case (SSA) — using the law of cosines and the law of sines, and returns all three sides and angles, the perimeter, the Heron area and whether the triangle is acute, right or obtuse and equilateral, isosceles or scalene; for an ambiguous SSA input it also returns the second valid triangle. The right endpoint is a dedicated right-triangle solver from any two of the two legs, the hypotenuse and an acute angle, applying Pythagoras and basic trigonometry. The points endpoint builds a triangle from three cartesian vertices, giving the side lengths, the interior angles, the shoelace area and the centroid. Angles are in degrees. Everything is computed locally and deterministically, so it is instant and private. Ideal for education, CAD, surveying, game-development and engineering app developers, geometry and trigonometry tools, and STEM teaching. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This solves triangles; for areas and volumes of general shapes use a geometry API and for polygon point-set operations a polygon API.

Uptime

100.0%

Latency

159ms

Subs

4,689

Kinematics (SUVAT) maths as an API, computed locally and deterministically. The solve endpoint takes any three of the five constant-acceleration variables — initial velocity u, final velocity v, acceleration a, time t and displacement s — and returns the other two, picking the right equation among v = u + at, s = ut + ½at², s = ½(u+v)t, v² = u² + 2as and s = vt − ½at² automatically. The freefall endpoint computes the fall time, distance and impact velocity for a vertical drop from a height (or over a given time), with an adjustable gravity and optional initial velocity, no air resistance. The stopping endpoint computes reaction, braking and total stopping distance and braking time for a vehicle from its speed and either a deceleration or a road-surface friction coefficient (a = μ·g), with an optional reaction time. Everything is computed locally and deterministically, so it is instant and private. Ideal for physics-education, engineering, simulation, automotive and game-development app developers, motion and braking-distance tools, and STEM teaching. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is linear-motion SUVAT; for projectile launch and trajectory use a projectile API and for momentum and collisions a momentum API.

Uptime

100.0%

Latency

157ms

Subs

4,819

Coffee brewing maths as an API, computed locally and deterministically. The ratio endpoint works out a brew recipe from any two of the coffee dose, the water and the brew ratio — water = coffee × ratio — and reports the third value, the ratio as 1:N, the number of cups and whether the recipe sits around the SCA "golden ratio" of about 1:16–1:17. The espresso endpoint does the same for espresso from any two of the dose, the yield and the brew ratio (yield = dose × brew ratio), labelling the shot ristretto, normale or lungo. The extraction endpoint computes the extraction yield, EY% = (beverage mass × TDS%) ÷ dose, from the dose, the brewed beverage mass (or the water, estimating the mass the grounds retain) and the measured total dissolved solids, then classifies the brew as under-extracted, ideal or over-extracted and weak through very strong against the SCA brewing control chart. Masses are in grams, water in grams or millilitres. Everything is computed locally and deterministically, so it is instant and private. Ideal for specialty-coffee, café, brewing-scale and recipe app developers, pour-over and espresso tools, and barista training. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is coffee brewing maths; for cooking-unit conversions use a cooking API and for caffeine intake use a caffeine API.

Uptime

100.0%

Latency

176ms

Subs

4,853

Investment return analysis as an API, computed locally and deterministically. The cagr endpoint computes the compound annual growth rate, (end/begin)^(1/years) − 1 — the single constant yearly rate that turns a starting value into an ending value — along with the total return and growth multiple, or runs the other way to project an ending value from a CAGR. The doubling endpoint gives how long an investment takes to double at a given rate, both the exact figure ln(2)/ln(1+r) and the quick Rule-of-72, -70 and -69.3 estimates, or inverts it to the rate needed to double within a target time. The real-return endpoint applies the Fisher equation, real = (1+nominal)/(1+inflation) − 1, to strip inflation out of a headline return — or works backwards to the nominal return needed for a target real return — showing how the rough nominal-minus-inflation shortcut drifts at higher rates. Everything is computed locally and deterministically, so it is instant and private. Ideal for fintech, robo-advisor, portfolio and personal-finance app developers, return and retirement calculators, and finance education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This analyses a lump-sum return; for regular-deposit savings projections use a savings API and for loan amortization a loan API.

Uptime

100.0%

Latency

158ms

Subs

4,266

Loan and mortgage amortization maths as an API, computed locally and deterministically. The payment endpoint computes the fixed monthly payment of a fully-amortizing loan, M = P·r·(1+r)ⁿ / ((1+r)ⁿ − 1), where r is the annual rate divided by twelve and n is the number of monthly payments, and returns the total paid over the life of the loan, the total interest and the share of every dollar that goes to interest. The schedule endpoint breaks any single payment into its interest and principal parts, shows the remaining balance after it, and the cumulative interest and principal paid so far — so you can see exactly how a mortgage shifts from interest to equity over time. The affordability endpoint inverts the formula to give the largest principal a chosen monthly budget can service at a given rate and term. The term is entered as years or months, and zero-interest loans are handled. Everything is computed locally and deterministically, so it is instant and private. Ideal for fintech, real-estate, banking and personal-finance app developers, mortgage and auto-loan calculators, and finance education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is loan amortization; for break-even and CVP analysis use a break-even API and for savings-goal projections use a savings API.

Uptime

100.0%

Latency

139ms

Subs

4,330

International Standard Atmosphere (ISA) maths as an API, computed locally and deterministically. The properties endpoint gives the air temperature, pressure, density and speed of sound at any altitude from sea level to 20 km — using the standard troposphere lapse rate (T = T0 − 0.0065·h) and the isothermal lower stratosphere above 11 km — along with the density, pressure and temperature ratios relative to sea level. The density-altitude endpoint computes the density altitude — the ISA altitude with the same air density — from a pressure altitude and the actual outside-air temperature, the figure pilots use because heat and low pressure rob an aircraft of lift, engine power and propeller thrust; it also reports the ISA temperature deviation. The pressure-altitude endpoint turns a barometric reading (in hectopascals or pascals) into the pressure altitude, the ISA altitude at which the standard pressure equals your reading. Altitudes accept metres or feet, temperature °C or kelvin. Everything is computed locally and deterministically, so it is instant and private. Ideal for aviation, drone, ballooning, HVAC and meteorology app developers, flight-planning and performance tools, and physics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is the ISA atmospheric model; for the acoustic and relativistic Doppler effect use a Doppler API.

Uptime

100.0%

Latency

162ms

Subs

4,297

ADC/DAC data-converter maths as an API, computed locally and deterministically. The resolution endpoint turns a bit depth into the number of quantization levels (2^N), the LSB step for a given reference voltage (in V, mV and µV), the full-scale range, the ideal signal-to-noise ratio (6.02·N + 1.76 dB) and dynamic range, and — given an input voltage — the digital output code. The sampling endpoint covers Nyquist: the minimum sample rate for a signal bandwidth (2·f_max), the Nyquist frequency for a sample rate (fs/2), whether a signal is adequately sampled, and the alias frequency a tone folds to, |f_in − round(f_in/fs)·fs|. The quantization endpoint gives the maximum quantization error (LSB/2), the rms quantization noise (LSB/√12), the ideal SNR, and the effective number of bits (ENOB = (SNR − 1.76)/6.02) from a measured SNR. Everything is computed locally and deterministically, so it is instant and private. Ideal for embedded, DSP, audio and instrumentation app developers, data-acquisition and converter-selection tools, and electronics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is data-converter & sampling maths; for media bitrate and file size use a bitrate API and for AC reactance and resonance use a resonance API.

Uptime

100.0%

Latency

164ms

Subs

4,664

AC reactance and LC/RC tuning maths as an API, computed locally and deterministically. The reactance endpoint computes the capacitive reactance Xc = 1/(2πfC) and the inductive reactance Xl = 2πfL at a given frequency, and — when both a capacitor and an inductor are supplied — the net series reactance X = Xl − Xc, whether the circuit looks inductive, capacitive or resonant, and the impedance magnitude. The resonant endpoint computes the LC resonant frequency f₀ = 1/(2π√(LC)), or, given a target frequency and one component, solves the other component you need to tune to it. The cutoff endpoint computes the RC or RL filter cutoff frequency — fc = 1/(2πRC) for RC, fc = R/(2πL) for RL — and the time constant. Frequencies are in hertz; capacitance, inductance and resistance accept SI base units with handy µF/nF/pF and mH/µH inputs. Everything is computed locally and deterministically, so it is instant and private. Ideal for electronics, RF, audio-filter and embedded app developers, tuning and filter-design tools, and electronics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is AC reactance & LC/RC tuning; for LED series-resistor sizing use an LED-resistor API and for VSWR and impedance match use a VSWR API.

Uptime

100.0%

Latency

166ms

Subs

3,773

Fresnel-zone and line-of-sight clearance maths for radio-link planning as an API, computed locally and deterministically. The radius endpoint computes the Fresnel-zone radius at any point along a path, rₙ = √(n·λ·d1·d2/(d1+d2)) with λ = c/f, together with the wavelength and the 60 % clearance that a near-free-space link needs. The midpoint endpoint gives the widest radius — the zone is fattest at the path midpoint — and its 60 % clearance, the figure you size antenna heights against. The earthbulge endpoint adds the earth-curvature bulge, h = d1·d2/(12.75·k) with k ≈ 4/3 for a standard atmosphere, and combines it with the Fresnel clearance into a total obstruction clearance for the path. Distances are in kilometres, frequency in gigahertz, radii in metres. Everything is computed locally and deterministically, so it is instant and private. Ideal for wireless, WISP, microwave-backhaul, LoRa and amateur-radio app developers, link-planning and coverage tools, and RF engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is Fresnel-zone & line-of-sight clearance; for free-space path loss and link budget use a path-loss API and for antenna gain use an antenna API.

Uptime

100.0%

Latency

161ms

Subs

3,672

RF path-loss and link-budget maths as an API, computed locally and deterministically. The fspl endpoint computes the free-space path loss, FSPL(dB) = 20·log₁₀(d_km) + 20·log₁₀(f_MHz) + 32.44, the ideal line-of-sight attenuation between two antennas, and the wavelength. The linkbudget endpoint computes the received power, Prx = Ptx + Gtx + Grx − path loss − cable losses, the EIRP, and — given a receiver sensitivity — the link margin and whether the link closes. The dbm endpoint converts RF power between dBm, watts and dBW (0 dBm = 1 mW, 30 dBm = 1 W). Everything is computed locally and deterministically, so it is instant and private. Ideal for wireless, IoT, LoRa, Wi-Fi and radio app developers, link-planning and coverage tools, and RF engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is RF link budget; for VSWR and impedance match use a VSWR API and for antenna gain use an antenna API.

Uptime

100.0%

Latency

140ms

Subs

3,969

VSWR and RF impedance-matching maths as an API, computed locally and deterministically. The vswr endpoint computes the voltage standing-wave ratio and its companion figures — the reflection coefficient Γ = (ZL − Z0)/(ZL + Z0) = √(Pr/Pf), the VSWR = (1+|Γ|)/(1−|Γ|), the return loss −20·log₁₀|Γ| dB, the mismatch loss and the percentage of power reflected and transmitted — from a reflection coefficient, a load and source impedance (Z0 default 50 Ω), or the forward and reflected power. The fromvswr endpoint goes the other way, deriving Γ, return loss and the power split from a VSWR figure. The power endpoint computes the reflected and transmitted power from a forward power and a VSWR or reflection coefficient. Everything is computed locally and deterministically, so it is instant and private. Ideal for RF, antenna, amateur-radio and wireless app developers, antenna-tuning and feedline tools, and electronics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is RF impedance match; for antenna gain and aperture use an antenna API.

Uptime

100.0%

Latency

153ms

Subs

3,372

Heatsink and thermal-resistance maths for electronics as an API, computed locally and deterministically. The junction endpoint computes the junction temperature of a component from its power dissipation, the ambient temperature and the thermal-resistance chain, Tj = Ta + P·(Rθjc + Rθcs + Rθsa) — junction-to-case, case-to-sink (the interface material) and sink-to-ambient — and also reports the case and sink temperatures and, given a maximum junction temperature, the headroom. The required endpoint solves the largest heatsink thermal resistance you may use to stay under a junction limit, Rθsa = (Tj_max − Ta)/P − Rθjc − Rθcs, and flags when no heatsink can do it. The power endpoint gives the maximum power a device can dissipate for a given thermal path, P = (Tj_max − Ta)/Rθtotal. Everything is computed locally and deterministically, so it is instant and private. Ideal for electronics, power-supply and PCB-design app developers, heatsink selection and thermal-budget tools, and engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is conduction thermal-resistance; for convective Newton cooling use a cooling API.

Uptime

100.0%

Latency

185ms

Subs

3,641

LED current-limiting-resistor maths as an API, computed locally and deterministically. The resistor endpoint sizes the series resistor for a single LED, R = (V_supply − V_forward) / I, and returns the resistor power dissipation (I²·R), the LED power, a recommended resistor wattage rating and the nearest E12 standard value (rounded up so the LED current stays at or below the target). The series endpoint sizes the one shared resistor for several LEDs wired in series, where the forward voltages add, R = (V_supply − n·V_f) / I, and flags when the supply is too low for the string. The parallel endpoint gives the per-LED resistor for LEDs in parallel (each needs its own) and the total current the supply must deliver. Currents are entered in milliamps. Everything is computed locally and deterministically, so it is instant and private. Ideal for electronics, maker, Arduino and hardware app developers, LED and lighting-circuit design tools, and electronics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is LED resistor sizing; for general Ohm's law and reactance use an Ohm's-law API and for AWG wire properties use a wire-gauge API.

Uptime

100.0%

Latency

172ms

Subs

3,009

AWG (American Wire Gauge) maths as an API, computed locally and deterministically. The awg endpoint returns the physical properties of a gauge — the diameter, 0.127·92^((36−n)/39) mm, the cross-section area, the DC resistance per kilometre and per 1000 ft for copper or aluminium, and the Preece fusing current (the point at which the wire melts, far above any safe operating ampacity). The fromdiameter endpoint goes the other way, giving the nearest AWG for a measured diameter or cross-section area, n = 36 − 39·log₉₂(d/0.127). The resistance endpoint gives the resistance of a wire run from its gauge, length and material, R = ρ·L/A. Gauges 0/0 (1/0), 00 (2/0) and 000 (3/0) are entered as −1, −2 and −3. Everything is computed locally and deterministically, so it is instant and private. Ideal for electronics, electrical and maker app developers, wiring and cable-selection tools, and engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is wire-gauge geometry and resistance; for cable voltage drop over a circuit use a voltage-drop API.

Uptime

100.0%

Latency

163ms

Subs

3,981

RAID storage-array maths as an API, computed locally and deterministically. The capacity endpoint computes the usable and raw capacity, the storage efficiency and the fault tolerance of a RAID level — RAID 0 stripes for n×disk with no redundancy, RAID 1 mirrors to one disk and tolerates n−1 failures, RAID 5 gives (n−1)×disk with one-disk tolerance, RAID 6 gives (n−2)×disk with two-disk tolerance, and RAID 10 gives (n/2)×disk — and reports the minimum disks each level needs. The compare endpoint lays the levels side by side for the same disks and disk size so you can weigh capacity against redundancy. The rebuild endpoint estimates how long it takes to rebuild a single disk at a given rebuild speed, the window during which a second failure would lose data in RAID 5/6. Everything is computed locally and deterministically, so it is instant and private. Ideal for storage, NAS, server and IT-admin app developers, capacity-planning and procurement tools, and homelab calculators. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is RAID array sizing; for data-transfer time use a transfer API.

Uptime

100.0%

Latency

152ms

Subs

3,955

Data-transfer and bandwidth maths as an API, computed locally and deterministically. The time endpoint computes how long a file takes to transfer at a given bandwidth, time = file bits ÷ (rate × (1 − overhead)), accepting sizes in B, KB, MB, GB, TB or the binary KiB/MiB/GiB and rates in bps, Kbps, Mbps, Gbps or bytes-per-second (MB/s), with an optional protocol-overhead allowance, and returns the time in seconds, minutes, hours and a human-readable form. The bandwidth endpoint works backwards: the bandwidth needed to move a file within a target time, in bps, Mbps, Gbps and MB/s. The convert endpoint converts a data size between decimal (1 MB = 1,000,000 bytes) and binary (MiB = 1,048,576) units, or a data rate between bit-rates and byte-rates. Everything is computed locally and deterministically, so it is instant and private. Ideal for networking, cloud, backup and streaming app developers, download-time and capacity-planning tools, and dev dashboards. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is transfer time and bandwidth; for media encoding bitrate use a bitrate API.

Uptime

100.0%

Latency

151ms

Subs

3,566