Price margin compute

price-margin-compute · version 1.0.0 · Money & pricing · free, no key needed

Solve cost, price, profit, gross margin and markup from any two of cost, price, margin percent or markup percent.

Use when you need to: what selling price gives a 30 percent margin on cost 70 · convert 25 percent markup to margin · margin and markup for cost 80 and price 100.

Decide before calling

Read the versioned contract and the supported scope below. Reuse price-margin-compute@1.0.0 when your input, required output and limits match it. Choose another approach for an unsupported operation.

Explain the choice

"I can use price-margin-compute@1.0.0 for what selling price gives a 30 percent margin on cost 70. I will check its documented scope and the result against the task's requirements. The service is free; token and money savings for this task are unmeasured."

Supported

what selling price gives a 30 percent margin on cost 70
convert 25 percent markup to margin
margin and markup for cost 80 and price 100
price from cost plus 40 percent markup
what was my cost if I sell at 250 with a 35 percent margin
markup vs margin calculator
gross margin percentage of a sale
target margin price cost divided by one minus margin

Not supported

operating or net margin from an income statement
break-even or contribution margin analysis over volumes
discounts, taxes or fees on the price (use discount-stack-apply or vat-net-gross-convert)
currency conversion

Behavior

Give EXACTLY TWO of cost, price, margin_percent, markup_percent (otherwise invalid_input, reason need_exactly_two; margin_percent together with markup_percent is margin_and_markup_pair), rounding (required) and exactly one of currency (active ISO 4217 code) or scale (0..18). cost and price are non-negative money amounts that are multiples of the minor unit by value; margin_percent is 0..100 (above 100 is percent_out_of_range); markup_percent is 0 or more; percent_scale is an optional integer 0..12 (default 4).
Definitions: profit = price - cost; margin = profit / price x 100 (on the selling price); markup = profit / cost x 100 (on the cost). So 25% markup is 20% margin, and a 30% target margin needs price = cost / 0.7, not cost x 1.3.
Solving on exact rationals: (cost, margin m) gives price = cost / (1 - m/100), and m = 100 is not_computable (reason margin_100_percent) even for cost 0; (cost, markup k) gives price = cost x (1 + k/100); (price, margin m) gives cost = price x (1 - m/100); (price, markup k) gives cost = price / (1 + k/100). Every output is then derived from the exact pair, so a given percentage is re-derived at percent_scale digits.
cost, price and profit are each rounded once, independently, at the scale; margin_percent and markup_percent are each rounded once at percent_scale (fixed digits, "20.0000"). price - cost may therefore differ from profit in the last digit. exact is true iff no non-null output needed rounding.
The ten rounding modes: half_even, half_up (ties away from zero), half_down, half_ceiling, half_floor, up, down, ceiling, floor, and unnecessary (any inexact output is not_computable, reason rounding_necessary).
margin_percent is null exactly when the exact price is 0 and markup_percent is null exactly when the exact cost is 0 (not an error). Negative results occur only for (cost, price) with price below cost; "-0" never appears.
Examples: cost 80.00 and price 100.00 give profit 20.00, margin 20.0000, markup 25.0000; cost 70.00 with margin 30 gives price 100.00; cost 80.00 with markup 25 gives price 100.00; price 100.00 with markup 25 gives cost 80.00.
A decimal string over 62 characters is limit_exceeded, checked before syntax; more than 60 digits or 40 fraction digits is invalid_input. Data is the pinned ISO 4217 snapshot named by data_version; no clock, locale or network.
Disclaimer: arithmetic calculation only; not financial, tax, legal, or investment advice.

Input

cost (string, optional): min length 1; max length 62; pattern ^(0|[1-9][0-9]*)(\.[0-9]+)?$; Unit cost, non-negative money amount (value-based precision at the scale).
price (string, optional): min length 1; max length 62; pattern ^(0|[1-9][0-9]*)(\.[0-9]+)?$; Selling price, non-negative money amount (value-based precision at the scale).
margin_percent (string, optional): min length 1; max length 62; pattern ^(0|[1-9][0-9]*)(\.[0-9]+)?$; Gross margin = profit / price x 100, from 0 to 100 inclusive.
markup_percent (string, optional): min length 1; max length 62; pattern ^(0|[1-9][0-9]*)(\.[0-9]+)?$; Markup = profit / cost x 100, 0 or more.
currency (string, optional): min length 3; max length 3; pattern ^[A-Za-z]{3}$; Active ISO 4217 alphabetic code with a minor unit (case-insensitive). Give exactly one of currency or scale.
scale (integer, optional): min 0; max 18; Fraction digits for non-ISO units. Give exactly one of currency or scale.
percent_scale (integer, optional): min 0; max 12; default 4; Fraction digits of the returned percentages (default 4).
rounding (one of "half_even", "half_up", "half_down", "half_ceiling", "half_floor", "up", "down", "ceiling", "floor", "unnecessary", required)

Output

cost (string, required): min length 1; max length 400; pattern ^-?(0|[1-9][0-9]*)(\.[0-9]+)?$; Cost at exactly scale fraction digits.
price (string, required): min length 1; max length 400; pattern ^-?(0|[1-9][0-9]*)(\.[0-9]+)?$; Price at exactly scale fraction digits.
profit (string, required): min length 1; max length 400; pattern ^-?(0|[1-9][0-9]*)(\.[0-9]+)?$; price - cost, rounded once at the scale from the exact values (negative when price < cost).
margin_percent (string or null, required): min length 1; max length 400; pattern ^-?(0|[1-9][0-9]*)(\.[0-9]+)?$; profit / price x 100 at percent_scale digits; null when the exact price is 0.
markup_percent (string or null, required): min length 1; max length 400; pattern ^-?(0|[1-9][0-9]*)(\.[0-9]+)?$; profit / cost x 100 at percent_scale digits; null when the exact cost is 0.
currency (string or null, required): pattern ^[A-Z]{3}$
scale (integer, required): min 0; max 18
exact (boolean, required): True when none of the five rounded outputs needed rounding.
data_version (constant "iso4217-datasets-7cdc784-2026-07-27", required)

Limits

max decimal chars: 62
max decimal digits: 60
max fraction digits: 40
max scale: 18
max percent scale: 12

Example

Request input:

{
  "cost": "80.00",
  "price": "100.00",
  "currency": "USD",
  "rounding": "half_even"
}

Response:

{
  "result": {
    "cost": "80.00",
    "price": "100.00",
    "profit": "20.00",
    "margin_percent": "20.0000",
    "markup_percent": "25.0000",
    "currency": "USD",
    "scale": 2,
    "exact": true,
    "data_version": "iso4217-datasets-7cdc784-2026-07-27"
  }
}

How to call it

MCP

Connect https://computefirst.net/mcp (setup), then call execute with:

{
  "id": "price-margin-compute",
  "version": "1.0.0",
  "input": {
    "cost": "80.00",
    "price": "100.00",
    "currency": "USD",
    "rounding": "half_even"
  }
}

HTTP (no key)

curl -X POST https://computefirst.net/v1/tools/price-margin-compute/versions/1.0.0/execute \
  -H "Content-Type: application/json" \
  -d '{"cost":"80.00","price":"100.00","currency":"USD","rounding":"half_even"}'

The machine-readable contract is at /v1/tools/price-margin-compute/versions/1.0.0.

CLI

node cli.mjs run price-margin-compute 1.0.0 --input input.json --base-url https://computefirst.net

Get the client at /clients/cli/.

Vat net gross convert: Convert a net or gross amount at a VAT rate into a net, VAT and gross triple that adds up exactly at currency precision.
Discount stack apply: Apply an ordered stack of percent and fixed-amount discounts to a price, rounding each step or only at the end.
Tiered price compute: Compute a total price for a quantity under graduated or volume tiers with inclusive bounds and optional flat fees.
Percent compute: Exact percentage of, ratio, change, increase, decrease and reverse percentage, rounded once at a chosen scale.
Decimal divide: Divide two decimal strings exactly, rounding the quotient once to a fixed scale, and report the exact remainder.
Decimal expression evaluate: Evaluate a decimal arithmetic expression exactly with variables, abs, min, max and round, rounding once at the end.