ForHosting KIT · Developer Utilities

Third-Degree Price Discrimination Calculator

This third-degree price discrimination calculator finds the profit-maximizing price for each of two separated markets when both face the same constant marginal cost.

● BetaFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Enter each market's point price elasticity of demand as a signed negative value or a positive magnitude. The calculator applies the inverse-elasticity pricing rule, reports each optimal price and markup, and identifies which market receives the higher price. It is designed for textbook analysis, planning scenarios, and transparent checks of segmented pricing decisions under the standard monopoly assumptions.

Enter elasticities and marginal cost consistently

Start with the constant marginal cost of supplying one additional unit. It must use the same currency and unit basis as the prices you want to obtain: if marginal cost is dollars per subscription-month, the resulting prices are dollars per subscription-month. Then enter the point price elasticity of demand for each market. Economists often report own-price elasticity as a negative number because quantity demanded moves opposite to price, while business summaries frequently quote only its positive magnitude. This calculator accepts either convention and uses the absolute value in the pricing formula. Each elasticity magnitude must exceed one. An elasticity of exactly one makes the inverse-elasticity expression undefined, while a magnitude below one does not support a finite interior monopoly price under this rule. The two markets must be separable enough that customers cannot cheaply buy in the lower-price market and resell in the higher-price market. They should also be measured at, or reasonably near, the prices being evaluated, because elasticity can change along a demand curve. Do not mix an elasticity estimated for a broad industry with a firm-specific marginal cost unless that combination matches the economic decision you intend to model.

Understand the inverse-elasticity calculation

For each market, the calculator applies the Lerner condition: the markup as a share of price equals one divided by the absolute demand elasticity. Rearranging that condition gives price equal to marginal cost multiplied by elasticity magnitude divided by elasticity magnitude minus one. Because the calculation is performed separately, a market with less elastic demand receives the higher profit-maximizing price. For example, with the same marginal cost, an elasticity magnitude of two permits a larger proportional markup than a magnitude of four. The output shows the entered elasticity, its magnitude, the optimal price, the currency-unit markup over marginal cost, and the Lerner index. It also subtracts market 2's price from market 1's price and labels the higher-priced market, making comparison immediate. A positive difference means market 1 is priced higher; a negative difference means market 2 is priced higher; zero means the two elasticity magnitudes imply equal prices. Results are rounded only for stable display. Automated API requests cost $0.002, and the calculation uses no external market feed, random input, or changing data.

Interpret the result within the model's limits

Treat the prices as conditional economic recommendations, not as proof that a discrimination program is feasible or lawful. The rule assumes a profit-maximizing seller with market power, constant shared marginal cost, independently served segments, and reliable point elasticities at the optimum. It does not estimate demand, quantities, fixed costs, capacity constraints, taxes, customer acquisition costs, strategic competitor reactions, or the administrative cost of keeping markets separate. It also does not calculate total profit because elasticities and marginal cost alone do not reveal how many units will be sold. If marginal cost differs between markets because of shipping, support, regulation, or payment processing, a shared-cost calculation is the wrong specification; analyze the segments with their actual incremental costs. Use sensitivity analysis when elasticities are uncertain: values close to one produce very large prices and make estimates especially fragile. Before implementing different prices, review applicable competition, consumer-protection, and anti-discrimination rules and consider customer trust. The strongest use of this output is as a clear benchmark that shows how differences in price sensitivity, holding marginal cost constant, translate into different theoretical markups.

What you can do with it

Compare regional pricing

Estimate theoretical prices for two geographically separated markets with different measured demand elasticities and the same incremental production cost.

Check an economics exercise

Verify two-market monopoly prices, markups, Lerner indices, and which segment should carry the higher price.

Run elasticity sensitivity scenarios

Replace either elasticity estimate to see how uncertainty in price responsiveness changes the recommended segmented price.

FAQ

Which formula does the calculator use?

For each market it uses P = MC × |e| / (|e| − 1), equivalent to the Lerner condition (P − MC) / P = 1 / |e|.

Can I enter negative demand elasticities?

Yes. You may enter the conventional negative own-price elasticity or its positive magnitude; the calculator uses the absolute value.

Why must each elasticity magnitude exceed one?

The inverse-elasticity rule has no finite interior monopoly price at a magnitude of one, and magnitudes below one imply that raising price increases revenue under the local model.

Does the less elastic market receive the higher price?

Yes, when both markets share the same marginal cost and the model's assumptions hold. Less elastic demand supports a larger optimal markup.

Does this calculate profit or quantities sold?

No. Elasticity and marginal cost determine the theoretical markup rule, but total demand levels are also required to calculate quantities, revenue, or profit.

What does an API calculation cost?

Each API request costs $0.002. The browser calculation is deterministic and requires no external data source.

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/price-discrimination-two-markets

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/price-discrimination-two-markets \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"marginal_cost":20,"market_1_elasticity":-2,"market_2_elasticity":-4}'

const res = await fetch("https://api.kit.forhosting.com/econ/price-discrimination-two-markets", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "marginal_cost": 20,
    "market_1_elasticity": -2,
    "market_2_elasticity": -4
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/econ/price-discrimination-two-markets",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "marginal_cost": 20,
    "market_1_elasticity": -2,
    "market_2_elasticity": -4
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/econ/price-discrimination-two-markets", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"marginal_cost":20,"market_1_elasticity":-2,"market_2_elasticity":-4}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"marginal_cost":20,"market_1_elasticity":-2,"market_2_elasticity":-4}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/econ/price-discrimination-two-markets", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "marginal_cost": 20,
  "market_1_elasticity": -2,
  "market_2_elasticity": -4
}

Example response

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

Read the full KIT documentation →