Cobb-Douglas production function
With capital of 25, labor of 36 and both elasticities at 0.5, Cobb-Douglas output is 30 and returns to scale are constant. Enter your inputs and exponents to get output, the elasticity sum and the returns-to-scale verdict together. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Capital
- 25
- Labor
- 36
- Capital elasticity
- 0.5
- Labor elasticity
- 0.5
- Production
- 30
- Tfp
- 1
- Elasticity sum
- 1
- Returns to scale
- constant
The Cobb-Douglas production function is the workhorse two-factor identity of intermediate microeconomics, growth accounting, and operations planning: total output equals total factor productivity times capital raised to its output elasticity times labor raised to its output elasticity. Students, tutors, and plant notebooks need that quantity without mixing the technology coefficient A with the exponents alpha and beta, or treating a negative stock as a valid input. This Cobb-Douglas production function calculator accepts non-negative capital and labor, their output elasticities, and an optional productivity term that defaults to one, applies Y equals A times K to the alpha times L to the beta, and returns total production together with the sum of elasticities and the implied returns-to-scale regime.
What Y = A · K^α · L^β means and how returns to scale appear
Charles Cobb and Paul Douglas popularized a multiplicative production identity in which each factor contributes a power of its own quantity, scaled by a productivity residual. Writing Y for total production, A for total factor productivity, K for capital, L for labor, alpha for the output elasticity of capital, and beta for the output elasticity of labor, the two-factor form is Y equals A times K to the alpha times L to the beta.
Alpha is the percent change in output that follows a one-percent change in capital when labor is held fixed; beta is the analogous labor elasticity. Those exponents are not the same object as A: A shifts the entire surface, while alpha and beta govern curvature and the mix of factors. Homogeneity of degree alpha plus beta classifies returns to scale.
When the exponents sum to one, scaling both K and L by the same positive constant scales Y by that constant, which is constant returns to scale and the textbook competitive-firm case. When the sum is greater than one, the same proportional expansion of both inputs raises output by more than that proportion, which is increasing returns. When the sum is less than one, output rises by less, which is decreasing returns.
Zero capital with a strictly positive capital elasticity contributes a factor of zero, so production is zero; a zero exponent on a factor contributes a factor of one, including the empty-product convention that a zero base to the power zero is one.
Where a Cobb-Douglas calculator earns its keep
Principles and intermediate microeconomics courses use a Cobb-Douglas production function calculator so learners can convert any non-negative K, L, alpha, and beta into total production without mixing the productivity residual with the elasticities or flipping a sign on a stock. Exam generators and LMS plugins need a deterministic oracle that rejects negative inputs instead of inventing a complex power or a silent zero that a buggy grader might treat as success. Failed validation does not consume balance.
Keep requests small, pin the rounded production and elasticity-sum fields in tests, and you get reproducible two-factor output figures for homework, LMS plugins, and edge workers without standing up a full computable-general-equilibrium stack of your own.
What you can do with it
Classroom Cobb-Douglas checks
Let students enter capital, labor, and output elasticities and verify total production plus returns to scale against textbook worked examples.
LMS and exam auto-grading
Mark production-function items with a deterministic oracle that rejects negative stocks or elasticities and never invents a complex power.
Capacity and growth notebooks
Tabulate two-factor Cobb-Douglas scenarios in plant or growth-accounting sheets without copying exponent arithmetic into every row.
FAQ
What happens if capital, labor, or an elasticity is negative?
Cobb-Douglas inputs cannot be negative; a negative base with a fractional exponent would leave the reals, and those failures are not billed.
Do I have to supply total factor productivity A?
When you do send tfp it must be a finite number that is not negative.
How do I know if returns to scale are constant, increasing or decreasing?
Add the two elasticities. A sum of one means constant returns, above one means increasing returns and below one means decreasing returns. The calculator reports the sum and names the regime for you.
What do the elasticities alpha and beta mean?
Alpha is the percent change in output that follows a one percent change in capital while labor stays fixed; beta is the same for labor. They shape the curve, while productivity A shifts the whole curve up or down.
What happens if capital or labor is zero?
If that input has a positive elasticity, output is zero, because a zero factor multiplies everything by zero. If its elasticity is zero, the input counts as one and output depends only on the other factor.
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/fin/cobb-douglas-production-function \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"capital":25,"labor":36,"capital_elasticity":0.5,"labor_elasticity":0.5}'const res = await fetch("https://api.kit.forhosting.com/fin/cobb-douglas-production-function", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"capital": 25,
"labor": 36,
"capital_elasticity": 0.5,
"labor_elasticity": 0.5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/cobb-douglas-production-function",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"capital": 25,
"labor": 36,
"capital_elasticity": 0.5,
"labor_elasticity": 0.5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/cobb-douglas-production-function", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"capital":25,"labor":36,"capital_elasticity":0.5,"labor_elasticity":0.5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"capital":25,"labor":36,"capital_elasticity":0.5,"labor_elasticity":0.5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/cobb-douglas-production-function", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"capital": 25,
"labor": 36,
"capital_elasticity": 0.5,
"labor_elasticity": 0.5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.cobb_douglas_production_function",
"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
Any negative input fails with invalid_input instead of inventing a complex or mirrored output.
What Y = A · K^α · L^β means and how returns to scale appear
Negative stocks or negative elasticities are not part of this real-valued identity: a negative base raised to a fractional exponent would leave the reals, and a negative elasticity would say that more of a factor reduces output, which this calculator treats as invalid_input rather than a success payload with a complex or mirrored quantity.
Input contract, response fields, and validation rules
Optional tfp is the technology coefficient A and defaults to one when omitted; when present it must also be a finite number that is not negative. Optional decimals is an integer from zero through twelve and defaults to six, controlling half-up rounding on production, echoed inputs, and the elasticity sum. Example: capital twenty-five, labor thirty-six, both elasticities one half, and tfp omitted yields production thirty, elasticity sum one, and constant returns, because the square root of twenty-five is five and the square root of thirty-six is six. POST a JSON body with four required finite numbers, each greater than or equal to zero: capital (K), labor (L), capital_elasticity (alpha), and labor_elasticity (beta). Each required field may arrive as a JSON number or as a numeric string; common aliases are accepted in transport: k or K for capital, l or L for labor, alpha or a_k or elasticity_k for capital elasticity, beta or a_l or elasticity_l for labor elasticity, and A or technology or productivity or total_factor_productivity for tfp. Missing fields, empty strings, non-finite values, negatives, values larger than one quadrillion in absolute value, and out-of-range decimals fail with invalid_input naming the field, and those failures are not billed. On success the body returns production as total output Y, the echoed and rounded inputs, tfp as used (one if defaulted), elasticity_sum as alpha plus beta, returns_to_scale as the string constant, increasing, or decreasing according to whether that sum equals, exceeds, or falls short of one within a tiny numerical tolerance, and formula as the short identity Y = A · K^α · L^β. Pair the numbers with your own units and estimated elasticities if you need a fitted industry surface; this endpoint applies only the two-factor identity and does not estimate parameters from data.
Where a Cobb-Douglas production function API earns its keep
Operations notebooks, plant-capacity slides, and growth-accounting workbooks often tabulate Cobb-Douglas scenarios for a board pack or a problem set; pinning the arithmetic in a tiny parse API keeps spreadsheet drift out of the comparison column.
Technical questions
How do I compute Cobb-Douglas production from capital and labor?
Send non-negative finite numbers capital (K), labor (L), capital_elasticity (α), and labor_elasticity (β). Optional tfp (A) defaults to 1. The API returns Y = A · K^α · L^β as production, plus the elasticity sum and the returns-to-scale regime.
What does returns_to_scale mean in the response?
It is constant when α + β equals 1, increasing when the sum is greater than 1, and decreasing when the sum is less than 1. The comparison uses a tiny numerical tolerance so textbook constant-returns examples are not misclassified by floating-point noise.
What does the Cobb-Douglas production function calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.