ForHosting KIT · Finance & money

Unit-elastic price calculator

For demand that starts at a price of 100 and falls by 2 per unit, elasticity equals 1 at a price of 50 and a quantity of 25, where revenue peaks at 1250. It is the revenue peak, not the profit peak. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Intercept: 100
Slope: 2

You get

Unit elastic price: 50
Quantity: 25
Total revenue: 1,250
Abs elasticity: 1

On a downward-sloping linear demand curve, point price elasticity changes from highly elastic near the choke price to inelastic near the quantity intercept, and it equals one at a single interior point. That unit-elastic price is also the unique price that maximizes total revenue, because marginal revenue crosses zero exactly where absolute elasticity equals one. Students, tutors, and pricing notebooks need that price, the matching quantity, and the peak revenue without mixing inverse-demand and direct-demand intercepts or treating the midpoint rule as a profit-max condition.

Why |ε| equals one at the midpoint and why that price maximizes revenue

Write inverse demand as price equals intercept a minus slope b times quantity, so the vertical intercept is the choke price at which quantity demanded is zero and the curve falls linearly toward the quantity intercept a over b. Point price elasticity on that line is the product of the slope of quantity with respect to price and the ratio of price to quantity. Substituting Q equals (a minus P) over b yields the compact identity that absolute elasticity equals P over (a minus P).

Setting that ratio equal to one immediately gives P-star equals a over two: the price halfway down from the choke price to the axis. The matching quantity is a over two b, which is also the horizontal midpoint of the demand segment. The same point is the unique total-revenue maximum.

Revenue as a function of price is TR equals P times (a minus P) over b, a downward-opening parabola whose derivative is (a minus two P) over b; that derivative is zero only at P equals a over two. Equivalently, marginal revenue on linear demand is a minus two bQ, which is zero at Q equals a over two b. Above the midpoint, demand is elastic and a small price cut raises revenue; below it, demand is inelastic and a small price cut lowers revenue.

This calculator therefore reports the unit-elastic price, the midpoint quantity, the peak total revenue, absolute elasticity of one, and marginal revenue of zero as a single consistent packet. It does not claim that this price maximizes profit: profit maximization still requires marginal cost, and a positive marginal cost would push the firm up the elastic portion of the curve.

Where the unit-elastic price is useful

Principles and intermediate micro courses use a unit-elastic price point calculator so students can convert any linear inverse-demand intercept and slope into the textbook midpoint price, quantity, and peak revenue without flipping the elasticity formula or confusing the vertical intercept with the quantity intercept. Exam generators and LMS plugins need a deterministic oracle that rejects a non-positive intercept or slope instead of silently returning a zero price that a buggy grader might treat as success. Failed validation does not consume balance.

Keep requests small, pin the rounded price, quantity, and revenue fields in tests, and you get reproducible midpoint numbers for homework, LMS plugins, and edge workers without standing up a full computational-economics stack of your own.

What you can do with it

Classroom midpoint and elasticity checks

Let students enter the intercept and slope of P=a−bQ and verify that the unit-elastic price is a/2, quantity is a/(2b), and |ε| equals one at that point.

LMS and exam auto-grading

Mark linear-demand revenue-max items with a deterministic oracle that rejects non-positive intercepts or slopes and never invents a second interior peak.

Pricing notebooks before adding cost

Compute the linear-demand revenue peak as a baseline before introducing marginal cost, capacity, or multi-product constraints in a separate step.

FAQ

How do I find the unit-elastic price on a linear demand curve?

Send the inverse-demand intercept a and slope b in P=a−bQ. The unit-elastic price is a/2, the matching quantity is a/(2b), and total revenue at that point is a²/(4b). Absolute elasticity equals one there.

Why is the unit-elastic price also the revenue-maximizing price?

On linear demand, TR=P(a−P)/b is a parabola in P whose derivative is zero only at P=a/2. Equivalently, marginal revenue a−2bQ is zero at the same midpoint. That is exactly where |ε|=P/(a−P) equals one.

What intercept and slope does the calculator expect?

It expects inverse demand P=a−bQ: intercept is the choke price a>0, and slope is the positive fall in price per unit of quantity b>0.

Is this the profit-maximizing monopoly price?

Profit maximization sets MR=MC. With positive marginal cost the firm prices on the elastic portion of demand, above the unit-elastic point.

What happens to revenue above and below the unit-elastic price?

Above it, demand is elastic, so a small price cut raises revenue. Below it, demand is inelastic, so a further cut lowers revenue. Revenue peaks exactly at the midpoint, 1250 in the example.

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

POSThttps://api.kit.forhosting.com/econ/unit-elastic-price

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/unit-elastic-price \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"intercept":100,"slope":2}'

const res = await fetch("https://api.kit.forhosting.com/econ/unit-elastic-price", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "intercept": 100,
    "slope": 2
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/econ/unit-elastic-price",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "intercept": 100,
    "slope": 2
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/econ/unit-elastic-price", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"intercept":100,"slope":2}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"intercept":100,"slope":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/econ/unit-elastic-price", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "intercept": 100,
  "slope": 2
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "econ.unit_elastic_price",
  "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

Per request$0.002

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

Input contract, response fields, and validation rules

Both must be strictly greater than zero so the curve has a positive choke price and slopes down. Optionally send decimals as an integer from zero through twelve (default six) to control half-up rounding on the computed price, quantity, and revenue fields. Example: intercept one hundred and slope two yields unit-elastic price fifty, quantity twenty-five, and total revenue one thousand two hundred fifty. If you estimated a direct-demand schedule Q equals alpha minus beta P instead, convert first: the inverse intercept is alpha over beta and the inverse slope is one over beta, then send those two numbers here. POST a JSON body with two required finite numbers: intercept, the price intercept a of inverse demand P equals a minus bQ, and slope, the positive slope parameter b that says how much price falls per extra unit sold. Common aliases are accepted: demand_intercept, a, choke_price, or price_intercept for intercept; demand_slope or b for slope. Missing fields, empty strings, non-finite values, zero or negative intercept or slope, and out-of-range decimals fail with invalid_input and are not billed. On success the body echoes intercept and slope, then returns unit_elastic_price as a over two, quantity as a over two b, total_revenue as a squared over four b, abs_elasticity as one, marginal_revenue as zero, and a formula string restating those identities. Pair the numbers with your own plot of the linear demand and the TR parabola if you need a figure; this endpoint returns the midpoint numbers only and does not emit charts or multi-step prose beyond the formula field.

Where a unit-elastic price point API earns its keep

Consulting notebooks and pricing sandboxes often tabulate linear-demand revenue peaks before they layer cost, capacity, or multi-product constraints; pinning the arithmetic in a tiny parse API keeps spreadsheet drift out of the comparison column.

Technical questions

What does the unit-elastic price point calculator cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free