ForHosting KIT · Finance & money

Shutdown-point price calculator

For a firm whose variable cost is 30q − 8q² + q³, average variable cost bottoms out at 14 at an output of 4: below a price of 14, producing nothing loses less. 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

Vc linear: 30
Vc quadratic: -8
Vc cubic: 1

You get

Shutdown quantity: 4
Shutdown price: 14
Mc at min: 14

A perfectly competitive firm covers its variable outlays only when the market price is at least as high as average variable cost. The short-run shutdown point is the lowest price at which that is still possible: the minimum of the AVC curve. Below that price the firm loses less by producing nothing, because every extra unit would add more to variable cost than it brings in as revenue, and fixed cost is already sunk. This shutdown-point price calculator takes the cubic variable-cost polynomial VC(q) equals a q plus b q squared plus c q cubed, locates the interior AVC minimum by calculus, and returns the shutdown quantity and the shutdown price P equals min AVC. Optionally it compares a market price to that floor and, when the firm should stay open, solves price equals marginal cost for the competitive supply quantity.

Why the short-run shutdown price is the minimum of average variable cost

A price-taking firm in the short run has already committed to its fixed cost. Rent, the lease on the plant, salaried overhead, and insurance are sunk: they are paid whether the firm produces a thousand units or zero. Variable cost is not sunk.

Materials, hourly labor, piece-rate wages, and energy tied to machine hours can be avoided by producing nothing. Economic profit equals total revenue minus total variable cost minus total fixed cost, so the operating decision reduces to whether revenue covers variable cost. Divide both sides by quantity and the same comparison is market price versus average variable cost.

If price lies below AVC at every positive output, every extra unit loses money on variable outlays, and the smallest short-run loss is the fixed cost itself, earned only by setting quantity to zero. The lowest price at which some positive output can still cover variable cost is therefore the minimum of the AVC curve. That price is the shutdown point.

At a price exactly equal to minimum AVC the firm is indifferent: producing the AVC-minimizing quantity and producing nothing both yield an operating profit of zero, so the loss equals fixed cost either way. Above that price the firm stays open and supplies along the rising branch of marginal cost, where price equals MC and MC is already above AVC. This calculator reports that floor from a cubic variable-cost polynomial and, when you send a market price, says whether the firm should stay open.

It does not answer the long-run exit question, which compares price with minimum average total cost rather than with minimum AVC.

What you can do with it

Classroom min-AVC checks

Let students enter the three coefficients of VC(q)=a q+b q²+c q³ and verify that the shutdown quantity is −b/(2c) and the shutdown price equals AVC at that output.

LMS and exam auto-grading

Mark short-run shutdown items with a deterministic oracle that rejects a non-U-shaped AVC and never treats a negative output as a valid shutdown point.

Plant stay-open versus idle

Compare a quoted spot price with min AVC from a fitted short-run cost curve and, if the line stays open, read the competitive supply quantity from P=MC.

FAQ

How do I calculate the short-run shutdown price from a cost function?

The shutdown quantity is q*=−b/(2c) and the shutdown price is P_s=AVC(q*)=a−b²/(4c). Shut down in the short run if the market price is below that floor.

Why shut down when price is below min AVC even if price is still positive?

Fixed cost is sunk in the short run and cannot be avoided. If price is below AVC at every positive output, each unit sold adds more to variable cost than it brings in as revenue, so producing anything makes the loss larger than fixed cost alone. Producing nothing loses only the fixed cost.

What is the difference between the shutdown point and the break-even (exit) point?

The shutdown point is P=min AVC and governs the short-run stay-open decision. The break-even or long-run exit point is P=min ATC, which also covers fixed cost. A firm can produce in the short run at a price between min AVC and min ATC, covering variable cost and part of fixed cost, and still plan to exit later.

What happens if I add the market price?

You get a decision: shut down, indifferent or produce. When the firm should stay open, the calculator also finds the quantity where price equals marginal cost on its rising branch.

What does adding the fixed cost change?

It adds the average total cost at the shutdown quantity: minimum average variable cost plus fixed cost divided by that quantity. That figure is not the long-run exit price, which is the minimum of average total cost.

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/shutdown-point

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/shutdown-point \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"vc_linear":30,"vc_quadratic":-8,"vc_cubic":1}'

const res = await fetch("https://api.kit.forhosting.com/econ/shutdown-point", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "vc_linear": 30,
    "vc_quadratic": -8,
    "vc_cubic": 1
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/econ/shutdown-point",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "vc_linear": 30,
    "vc_quadratic": -8,
    "vc_cubic": 1
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/econ/shutdown-point", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"vc_linear":30,"vc_quadratic":-8,"vc_cubic":1}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"vc_linear":30,"vc_quadratic":-8,"vc_cubic":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/econ/shutdown-point", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "vc_linear": 30,
  "vc_quadratic": -8,
  "vc_cubic": 1
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "econ.shutdown_point",
  "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, the cubic cost polynomial, and the calculus

The shutdown price is then AVC at q-star, which simplifies to a minus b squared over four c, and must itself be strictly positive. Optionally send decimals as an integer from zero through twelve (default six) to control half-up rounding. POST a JSON body with three required finite numbers that define short-run variable cost VC(q) equals vc_linear times q plus vc_quadratic times q squared plus vc_cubic times q cubed. Those same numbers are the coefficients of AVC(q) equals a plus b q plus c q squared. vc_cubic must be strictly greater than zero so AVC is U-shaped. vc_quadratic must be strictly less than zero so the critical quantity q-star equals minus b over two c is positive. Common aliases are accepted: a or linear for vc_linear, b or quadratic for vc_quadratic, and c or cubic for vc_cubic. Optionally send market_price (aliases price, p) as a non-negative number to receive decision equal to shutdown, indifferent, or produce, plus supply_quantity on the rising MC branch when the firm stays open. Optionally send fixed_cost (aliases fc, total_fixed_cost) to receive atc_at_shutdown, which is min AVC plus fixed cost over q-star — ATC at the shutdown quantity, not the long-run exit price. Missing fields, empty strings, non-finite values, a non-positive cubic term, a non-negative quadratic term, a non-positive computed shutdown price, and out-of-range decimals fail with invalid_input and are not billed. On success the body echoes the three coefficients and returns shutdown_quantity, shutdown_price, mc_at_min (equal to min AVC by identity), and a formula string. Example: vc_linear thirty, vc_quadratic minus eight, vc_cubic one yields shutdown quantity four and shutdown price fourteen.

Where a shutdown-point price calculator earns its keep

Principles and intermediate micro courses use a shutdown-point price calculator so students can convert any cubic variable-cost polynomial into the textbook min-AVC price and quantity without dropping a sign on the derivative or confusing the shutdown rule with the break-even rule. Exam generators and LMS plugins need a deterministic oracle that rejects a non-positive cubic coefficient or a non-negative quadratic coefficient instead of silently returning a negative output or a price of zero that a buggy grader might treat as success. Failed validation does not consume balance. Plant-controller and operations notebooks often inherit a fitted short-run cost curve and must decide, for a quoted spot price, whether to idle the line or to supply along marginal cost; pinning that comparison in a tiny parse API keeps spreadsheet drift out of the stay-open column. Keep requests small, pin the rounded shutdown_price and shutdown_quantity fields in tests, and you get reproducible short-run floors for homework, LMS plugins, and edge workers without standing up a full computational-economics stack of your own.

Technical questions

What coefficients does the calculator expect, and can I send a market price?

It expects VC(q)=a q+b q²+c q³. vc_cubic must be positive and vc_quadratic must be negative so AVC is U-shaped with a positive minimizer. Optionally send market_price to receive the stay-open decision and, if the firm produces, the rising-MC supply quantity. Optionally send fixed_cost to receive ATC at the shutdown quantity.

What does the shutdown-point price 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