Selling price from markup calculator
Turn a unit cost and a markup into a list price: a cost of 50 with a 40% markup sells at 70, earning 20 per unit. You also see the matching gross margin, so markup and margin never get mixed up. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Unit cost
- 50
- Markup percent
- 40
- Markup amount
- 20
- Selling price
- 70
- Profit
- 20
- Margin percent
- 28.5714285714
Retailers, wholesalers, and product teams set list prices with a simple cost-plus rule: take the unit cost and add a chosen markup percentage. Getting that arithmetic wrong—confusing markup with margin, forgetting currency rounding, or hard-coding a one-off spreadsheet—quietly underprices SKUs or overpromises margin to finance. This selling price from markup calculator accepts a positive unit cost and a non-negative markup percent, multiplies cost by one plus markup over one hundred, and returns the selling price, the dollar profit (markup amount), and the equivalent gross margin percent with stable money rounding.
How selling price, profit, and margin are computed
The identity is the classic cost-plus formula used in merchandising and managerial accounting. Selling price equals unit cost multiplied by one plus markup percent divided by one hundred. Profit per unit equals selling price minus unit cost, which is the same dollar amount as the markup amount field returned for display on price cards.
Margin percent is profit divided by selling price, then multiplied by one hundred, so finance teams who speak in gross margin can read the equivalent rate without a second conversion tool. Percentage fields keep a fine stable scale for the same reason. Example: unit cost fifty with markup forty percent yields selling price seventy, markup amount twenty, profit twenty, and margin percent about twenty-eight point five seven.
Example: unit cost eighty with markup twenty-five percent yields selling price one hundred, profit twenty, and margin twenty percent. The response always echoes the normalized unit cost and markup percent, the four money and rate fields, and a formula string restating the identities for UI tooltips.
What you can do with it
Retail shelf and catalog list pricing
Merchants enter unit cost and a target markup percent, then lock the resulting selling price and unit profit into the product catalog.
Wholesale and vendor cost-plus quotes
Sales teams apply a standard markup to supplier cost and publish a consistent list price without reimplementing cost-plus math in every spreadsheet.
FAQ
How do I calculate selling price from markup?
The response also includes profit and the equivalent margin percent.
What is the difference between markup and margin?
Markup is profit as a percentage of cost. Margin is profit as a percentage of selling price. A 25% markup on cost is a 20% margin on the selling price—not the same number.
What markup turns a cost of 80 into a price of 100?
A 25% markup: a quarter of 80 is 20, so the price is 100 and the profit 20 per unit. That same profit is a 20% margin, because margin is measured against the selling price, not the cost.
Can I enter a negative markup to sell below cost?
No. The markup must be zero or more, and the unit cost must be above zero. Selling below cost is a discount, not a markup, so the calculator rejects it rather than publish a hidden markdown.
How are the results rounded?
Money amounts are rounded to two decimals by default, like an ordinary quote. You can choose anywhere from 0 to 8 decimals if your catalog or currency needs a different precision.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/finance/selling-price-from-markup \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"unit_cost":50,"markup_percent":40}'const res = await fetch("https://api.kit.forhosting.com/finance/selling-price-from-markup", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"unit_cost": 50,
"markup_percent": 40
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/finance/selling-price-from-markup",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"unit_cost": 50,
"markup_percent": 40
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/finance/selling-price-from-markup", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"unit_cost":50,"markup_percent":40}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"unit_cost":50,"markup_percent":40}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/finance/selling-price-from-markup", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"unit_cost": 50,
"markup_percent": 40
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "finance.selling_price_from_markup",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
Failed validation is not billed; successful API items use the published $0.002 base price.
Inputs: unit cost, markup percent, and optional decimals
Unit cost must be strictly positive; zero or negative cost is rejected because a cost-plus list price is undefined for non-positive cost bases. Optional decimals is an integer from zero through eight that controls how money-style fields are rounded in the response; when omitted it defaults to two so results look like ordinary currency on a quote. Send a JSON body with two required numbers and one optional scale control. unit_cost is the acquisition or production amount for one unit in a single currency you already track—aliases cost, cost_price, cogs, and wholesale are accepted when your client already names the field differently. Markup_percent is the uplift expressed as a percent of that cost: forty means a forty percent markup, so the selling price equals unit cost times one plus forty over one hundred. Aliases markup, markup_pct, and mu map to markup_percent for clients that speak retail shorthand. Markup percent must be non-negative; negative markup (a planned discount below cost) is out of scope for this calculator and fails with invalid_input so pricing bots never publish a silent markdown as if it were a markup. Extremely large costs or markups are capped so Worker isolate arithmetic stays bounded. All checks run before any multiplication, so bad requests never produce a half-filled price row and never consume prepaid balance after the engine rejects the body.
How selling price, profit, and margin are computed
Money fields unit_cost, markup_amount, selling_price, and profit are rounded with a half-up style to the requested decimals so goldens and SDK demos pin cleanly across runtimes. Identical inputs always produce identical JSON because the path is pure arithmetic with no network, no random seed, and no wall clock.
API usage, pricing workflows, and practical limits
Call the free in-browser selling price from markup calculator for shelf pricing workshops, vendor negotiations, and classroom exercises without installing a spreadsheet. Keep unit costs within ordinary commercial ranges; extreme values are rejected so isolate math stays bounded. The product promise is single-SKU cost-plus list pricing with explicit guards on positive cost and non-negative markup—not multi-product baskets, promotional stacking, dynamic competitor matching, or full markup-versus-margin conversion suites, which belong in specialized tools with different SEO intent and different primary search queries. Use the prepaid API when a catalog importer, ERP connector, ecommerce rule engine, or pricing chatbot needs a stable KIT contract at $0.002 per successful item; validation failures never consume balance after the engine rejects the request. Pair this endpoint with currency converters only if you already know amounts in one currency—this capability does not convert FX, apply sales tax, layer shipping, or convert between markup and margin as the primary product goal. Authors shipping SDKs can map unit_cost, markup_percent, selling_price, and profit directly into pricing tables and quote builders.
Integration use cases
Pricing bots and ERP connectors
Automations call a stable prepaid endpoint so catalog imports and rule engines share one deterministic contract for selling price from markup.
Technical questions
Can markup_percent be zero?
Yes. Zero markup means selling price equals unit cost and profit is zero. Negative markup is rejected with invalid_input.
What happens if unit_cost is zero or negative?
The task fails with invalid_input. Cost-plus pricing requires a positive unit cost; those failures are not billed.
What does the selling price from markup calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.