Optimal markup from demand elasticity
Turn a demand elasticity into the profit-maximizing markup: an elasticity of 2 gives a markup of 100% over marginal cost, a price twice marginal cost and a Lerner index of 0.5. Demand must be elastic. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Elasticity
- 2
- Elasticity input
- 2
- Abs elasticity
- 2
- Markup ratio
- 1
- Markup percent
- 100
The inverse-elasticity pricing rule is the workhorse link between residual demand and optimal price in intermediate microeconomics and industrial organization: a profit-maximizing firm with constant own-price elasticity sets the relative markup of price over marginal cost so that the Lerner index equals one over absolute elasticity. Students, tutors, and pricing notebooks need that percentage markup over cost without mixing signed and absolute elasticity conventions or confusing markup-on-cost with margin-on-price. This optimal markup from demand elasticity calculator accepts a finite own-price elasticity, requires elastic demand so a finite interior optimum exists, and returns the markup ratio and percent over marginal cost, the price-to-cost multiplier, and the implied Lerner index. Optionally supply marginal cost to obtain the optimal price level in money units.
What the inverse-elasticity rule says and when a finite markup exists
Under profit maximization with a smooth residual demand curve, the first-order condition equates marginal revenue to marginal cost. For constant own-price elasticity ε the marginal-revenue identity rearranges into the Lerner formula: price minus marginal cost, all over price, equals the negative reciprocal of ε. Writing η for the absolute value of elasticity, that is L equals one over η.
Multiplying through by price over marginal cost converts the price-normalized gap into a cost-normalized markup: (P minus MC) over MC equals one over (η minus one), and the optimal price-to-cost ratio is η over (η minus one). Those identities are the inverse-elasticity pricing rule used in textbooks, consulting slide decks, and simple constant-elasticity monopoly models. A finite positive interior markup requires elastic residual demand: η must be strictly greater than one.
When demand is unit-elastic, marginal revenue is zero everywhere and no positive finite price maximizes profit against constant average cost. When demand is inelastic, marginal revenue is negative and the firm would want to raise price without bound under the constant-elasticity assumption. Signed elasticities such as negative two and absolute elasticities such as two are accepted interchangeably; the engine always works with η equals the absolute value so classroom notation never flips the sign twice by accident.
Who uses the optimal markup rule
Principles and industrial-organization courses use an optimal markup from demand elasticity calculator so students can convert any elastic |ε| into the textbook percent markup over cost without confusing Lerner’s price-normalized gap with retail markup-on-cost. Exam generators and LMS plugins need a deterministic oracle that rejects unit-elastic and inelastic inputs instead of inventing an infinite or zero markup that a buggy grader might treat as success. Failed validation does not consume balance.
Keep requests small, pin the rounded markup and Lerner fields in tests, and you get reproducible monopoly-pricing numbers for homework, LMS plugins, and edge workers without standing up a full industrial-organization simulation stack of your own.
What you can do with it
Classroom inverse-elasticity checks
Let students enter |ε| or signed ε and verify markup percent over MC and the Lerner index against textbook worked examples.
LMS and exam auto-grading
Mark monopoly pricing items with a deterministic oracle that rejects |ε| ≤ 1 and never invents an infinite markup.
Pricing notebooks and scenarios
Batch-compute constant-elasticity optimal markups and optional optimal prices without spreadsheet formula drift.
FAQ
Should I send signed elasticity or absolute value?
Either works. Send |ε| > 1 (e.g. 2) or the signed value ε < −1 (e.g. −2). The engine always uses the absolute value.
Why is |ε| ≤ 1 rejected?
Under constant elasticity, unit-elastic or inelastic residual demand has no finite interior profit-maximizing price against positive marginal cost.
Is this the same as the Lerner index calculator?
Related but different intent. Lerner index is (P − MC)/P from price and cost.
How do I get the optimal price from the markup?
Add your marginal cost. The optimal price is marginal cost times the elasticity divided by the elasticity minus one. With an elasticity of 2, the price is twice marginal cost.
Why does more elastic demand mean a lower markup?
Because the markup over cost equals one divided by the elasticity minus one. As the elasticity grows, that fraction shrinks, so the firm can charge less above cost. An elasticity of 2 still allows 100%.
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/econ/markup-from-elasticity \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"elasticity":2}'const res = await fetch("https://api.kit.forhosting.com/econ/markup-from-elasticity", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"elasticity": 2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/econ/markup-from-elasticity",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"elasticity": 2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/econ/markup-from-elasticity", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"elasticity":2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"elasticity":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/econ/markup-from-elasticity", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"elasticity": 2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "econ.markup_from_elasticity",
"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
What the inverse-elasticity rule says and when a finite markup exists
This calculator therefore rejects |ε| less than or equal to one as invalid_input rather than returning infinity or a hollow zero that confuses graders.
Input contract, response fields, and validation rules
You may send the absolute value greater than one (for example two) or the signed textbook value less than negative one (for example negative two). Optional decimals is an integer from zero through twelve (default six) controlling half-up rounding on every computed field. Example: elasticity two yields markup ratio one, markup one hundred percent, price-over-MC of two, and Lerner index zero point five. POST a JSON body with one required finite number: elasticity, the own-price elasticity of demand. Optional marginal_cost, when present, must be a finite number strictly greater than zero and causes the response to include optimal_price equal to marginal cost times η over (η minus one). Missing elasticity, empty strings, non-finite values, zero elasticity, |ε| at most one, non-positive marginal cost, and out-of-range decimals fail with invalid_input and are not billed. Common aliases are accepted: e, epsilon, abs_elasticity, price_elasticity, or demand_elasticity for elasticity; mc, cost, or unit_cost for marginal_cost. On success the body returns elasticity_input (echoed and rounded), abs_elasticity, markup_ratio as (P minus MC) over MC, markup_percent as one hundred times that ratio, price_over_mc as the optimal P over MC multiplier, lerner_index as one over η, formula as a short identity string, and when cost was supplied also marginal_cost and optimal_price. With marginal_cost fifty the optimal price is one hundred. Pair the numbers with your own demand estimates if you need multi-product or quantity-dependent elasticities; this endpoint applies only the constant-elasticity inverse rule and does not estimate demand curves.
Where an optimal markup from elasticity API earns its keep
Consulting notebooks and pricing sandboxes often tabulate constant-elasticity scenarios for monographs or board slides; pinning the arithmetic in a tiny parse API keeps spreadsheet drift out of the comparison column.
Technical questions
How is the optimal markup from demand elasticity calculated?
With η = |ε| > 1, markup over MC is (P − MC)/MC = 1/(η − 1), so markup percent is 100/(η − 1). The API also returns P/MC = η/(η − 1) and Lerner L = 1/η.
What does the optimal markup from demand elasticity calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.