Popcorn yield calculator
A quarter cup of kernels pops into 8.75 cups of popcorn, because popcorn swells about 35 times: enter kernels by volume or weight and size the bowl before the first pop. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Amount
- 0.25 cups
- Input kind
- volume cups
- Expansion ratio
- 35
- Kernel density g per ml
- 0.8
- Kernel volume ml
- 59.147059125
Movie nights, concession stands, and home kitchens all start from a small measure of hard unpopped kernels and need a bowl large enough for the fluffy popped corn those kernels become. Typical popcorn expands about thirty-five times its unpopped volume, so a quarter cup of kernels fills a large mixing bowl while a fifty-gram handful can overflow a modest saucepan. This popcorn yield calculator accepts a positive kernel amount as volume or mass, converts mass to millilitres of kernels using a published bulk density of zero point eight grams per millilitre, multiplies by the typical expansion ratio, and returns the popped volume in millilitres, US cups, litres, and quarts. Zero, negative, missing, and non-numeric kernel amounts fail with invalid input instead of inventing a bowl size.
Why popcorn yield uses a typical expansion ratio and a kernel density
Popcorn is a high-moisture flint maize that inverts when steam inside the hull bursts the pericarp. The fluffy starch foam occupies far more space than the dense unpopped kernel, which is why a snack-size jar of kernels fills a cinema tub. Kitchen writers and concession managers have long used a typical expansion ratio of about thirty-five to one: one millilitre of unpopped kernels yields about thirty-five millilitres of popped corn under ordinary stovetop, air-popper, or microwave conditions.
That single factor is enough to size a bowl, a serving bag, or a warming tray without guessing from a photograph. Mass inputs need one extra step because a gram is not a millilitre. Unpopped kernels pack at a conventional bulk density of zero point eight grams per millilitre, so fifty grams occupy sixty-two point five millilitres before they pop and two thousand one hundred eighty-seven point five millilitres afterwards at the typical ratio.
The tool does not cook, salt, time, or oil the pop, and it does not model unpopped leftovers or hull fragments. The arithmetic is a pure multiply after unit conversion, with no network, no clock, and no random draw.
What you can do with it
Size a movie-night bowl from a jar of kernels
Enter a quarter cup or half cup of unpopped kernels and read popped cups so the mixing bowl is large enough before the first kernel bursts.
Concession bags from a gram weight of kernels
Send a positive kernel mass in grams or ounces and get popped millilitres, litres, and quarts for bag and warming-tray planning.
FAQ
How do I compute popped popcorn from unpopped kernels?
By default unit is cups, so the result is popped volume using the typical expansion ratio of thirty-five. Set unit to grams, kg, oz, or lb to start from mass instead.
What expansion ratio does the calculator use?
The default typical expansion ratio is 35, meaning popped volume is thirty-five times the unpopped kernel volume. Mass inputs first convert to millilitres with a kernel bulk density of 0.8 g/ml.
Can I enter kernels by weight instead of cups?
Yes. Set unit to grams, kg, oz, or lb with the same amount field.
What happens if the kernel amount is zero or negative?
Missing, infinite, and non-numeric amounts follow the same error path and are not charged.
Is the popcorn yield calculator free?
The browser tool runs free on your device.
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/cook/popcorn \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"amount":0.25}'const res = await fetch("https://api.kit.forhosting.com/cook/popcorn", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"amount": 0.25
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/cook/popcorn",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"amount": 0.25
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/cook/popcorn", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"amount":0.25}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"amount":0.25}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/cook/popcorn", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"amount": 0.25
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "cook.popcorn",
"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
Why popcorn yield uses a typical expansion ratio and a kernel density
You may send a custom expansion_ratio when a hybrid’s lab sheet already names a different factor, but the default is the published typical ratio rather than a random packing guess.
How to call the calculator and read the popped-volume fields
Optional field unit names the measure of that amount and defaults to cups so a kitchen search for how much popcorn a half cup of kernels makes lands on the expected path. Send a JSON body with the required number field amount set to a finite quantity of unpopped kernels that is strictly greater than zero. Aliases kernels, kernel_amount, quantity, value, and qty are accepted when your client already uses those labels. Volume units are cups, ml, liters, tbsp, tsp, fl_oz, and quarts; mass units are grams, kg, oz, and lb. The unit field is a closed list: unknown strings fail with invalid_input rather than silently assuming cups. Optional field expansion_ratio overrides the typical thirty-five when you already know a lab expansion for a specific hybrid; it must also be a positive finite number. On success the response echoes amount, the canonical unit, input_kind as volume or mass, the expansion_ratio actually used, kernel_density_g_per_ml, kernel_volume_ml, kernel_mass_g, and the popped volume as popped_volume_ml plus popped_cups, popped_liters, and popped_quarts so a user interface can show the unit the cook already thinks in. A method tag typical_popcorn_expansion and a short formula string document the multiply. Zero, negative, empty, infinite, and non-numeric amounts fail with invalid_input because the kernel amount is not a positive number, and those validation failures are not charged.
Kitchen workflows, concession sheets, limits, and API pricing
Use the free in-browser popcorn yield calculator when packing a movie-night bowl from a jar of kernels, checking whether a saucepan will hold a measured scoop, or teaching students why a quarter cup of kernels becomes several cups of snack. Remember that oil, sugar for kettle corn, and unpopped leftovers change the edible mass but not the geometric expansion this tool reports; the result is popped volume, not a nutrition label or a popping-time chart. Failed validation is not billed, so a zero kernel line in a generated sheet fails cleanly instead of returning a silent empty bowl. Use the prepaid API when a concession app, cafeteria sheet, recipe CMS, or localization pipeline must convert many kernel lines under a stable contract at $0.002 per successful item. Pair this endpoint with a cups-to-grams converter when the next pantry line is flour rather than popcorn, or with a recipe scaler when the whole snack mix grows by a serving factor. Authors shipping software development kits can map popped_cups next to popped_volume_ml with the expansion ratio as a subtitle, matching how home cooks already compare bag labels and mixing bowls on paper.
Integration use cases
Normalize kernel lines in recipe pipelines
Meal-planning and snack-mix APIs accept mixed cup and gram kernel inputs and emit a stable popped-volume JSON contract for every successful item.