Recipe portion scaler
Going from 4 to 6 servings multiplies every amount by 1.5, so 250 g of flour becomes 375 g and 2 eggs become 3. Enter the original and target servings and your list of amounts to get the scaled recipe. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Amounts
- 250, 100, 2, 1
- Original servings
- 4
- Target servings
- 6
- Names
- flour (g), sugar (g), eggs, salt (tsp)
- Scaled
- 375, 150, 3, 1.5
- Scale factor
- 1.5
- Quantity
- 4
A recipe portion scaler takes every numeric amount on your ingredient list and multiplies it by one shared factor so a dish written for four people becomes a tray for twelve, or a half-batch for two, without rewriting the card by hand. Enter the original serving count, the target serving count, and the amounts as a list of positive numbers; the tool derives factor equals target divided by original and returns the scaled list with optional name labels kept in the same order.
What portion scaling means and when to change the serving count
Home cooks, meal-prep services, dietitians building sample menus, and test kitchens all face the same arithmetic problem: a published formula lists fixed quantities for a fixed yield, but the table tonight needs a different yield. Portion scaling multiplies every scalable amount by the same factor so relative ratios stay constant—twice the flour still meets twice the water at the same hydration, and half the oil still seasons half the greens. The factor is not guessed: it is exactly target servings divided by original servings.
Four people to six people is a factor of one point five; eight people to two people is a factor of zero point two five. The tool accepts a non-empty list of finite positive numbers as amounts, required positive original and target serving counts, and optional parallel name labels so the response can echo flour, sugar, and salt next to the new figures.
Units are not converted here; two hundred fifty stays two hundred fifty until you decide whether it is grams or millilitres, and the scaled result keeps the same unit convention you already used. That separation is intentional: flour density converters and tablespoon-to-millilitre tools solve unit questions, while this capability only answers how much of each listed line you need after the batch size changes.
What you can do with it
Catering yield from a test-kitchen batch
Convert a pilot batch written for eight plates into a service count of forty-eight by sending original and target servings so the factor is derived automatically.
FAQ
How does the recipe portion scaler work?
Both serving counts and every amount must be finite and strictly positive. Optional names stay aligned with each line.
What happens if original or target servings is zero or negative?
Non-positive serving counts are rejected because they do not define a meaningful batch size.
Can I scale down as well as up?
Yes. Any positive target smaller than the original (for example 2 from 8) yields a factor below one and reduces every amount proportionally.
Does this convert cups to grams?
No. It only scales numbers. Keep units consistent yourself, or use a dedicated converter first, then scale the resulting amounts.
Can I label each ingredient?
Yes. Add optional names in the same order as the amounts, such as flour (g), sugar (g), eggs and salt (tsp). Putting the unit in the label keeps the number clean and the scaled list easy to read.
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/health/recipe-portion-scaler \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"amounts":[250,100,2,1],"original_servings":4,"target_servings":6}'const res = await fetch("https://api.kit.forhosting.com/health/recipe-portion-scaler", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"amounts": [
250,
100,
2,
1
],
"original_servings": 4,
"target_servings": 6
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/health/recipe-portion-scaler",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"amounts": [
250,
100,
2,
1
],
"original_servings": 4,
"target_servings": 6
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/health/recipe-portion-scaler", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"amounts":[250,100,2,1],"original_servings":4,"target_servings":6}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"amounts":[250,100,2,1],"original_servings":4,"target_servings":6}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/health/recipe-portion-scaler", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"amounts": [
250,
100,
2,
1
],
"original_servings": 4,
"target_servings": 6
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "health.recipe_portion_scaler",
"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
Non-positive servings or amounts, empty lists, and non-finite values are rejected with invalid_input so bad data never produces a silent zero batch.
How to call the API: fields, validation, and the response shape
Each amount must likewise be positive and finite; an empty list is rejected because there is nothing to scale. Prefer putting units in the optional names field rather than inside amount strings so two hundred fifty and flour in grams stay separate and the solver never has to parse mixed text. Send a JSON body with amounts as a required array of finite positive numbers—or a comma-separated string on text forms—plus original_servings and target_servings (aliases include servings, from_servings, original for the source count, and target, to_servings, new_servings for the destination). Both serving counts must be strictly positive finite numbers; zero, negative, missing, or non-numeric values return invalid_input and are never charged. Absolute values stay within the published limit of one trillion, and the list length is capped so a Worker can finish quickly. On success the response echoes rounded amounts, scaled, scale_factor, original_servings, target_servings, count, optional names, ingredients rows pairing each original amount with its scaled value, formula, message, and ordered steps for audit trails. Failed validation—empty amounts, non-finite numbers, non-positive servings or amounts, or missing required fields—returns invalid_input with a message naming the problem. Pricing is a flat $0.002 per successful request with unit item and zero marginal unit price.
Practical tips, common mistakes, limits, and related tools
When scaling for guests, double-check that every line on the card is proportional—some recipes leave seasonings to taste or fix pan size, so you may scale bulk ingredients and leave spice pinches as judgment calls. Prefer numbers rather than pre-formatted unit strings inside amounts; put units in the optional names field instead. Prefer sibling cook or convert tools when you need flour cups to grams or tablespoons to millilitres, then scale the resulting numbers here. Round-trip checks are easy: recompute each amount times factor by hand and confirm it equals the published scaled entry within the same twelve-decimal rounding, and confirm that changing only the target scales every line proportionally while leaving labels aligned. Always keep original_servings non-zero and positive in client forms before submit; the API will still throw a clear invalid_input message if zero or a negative count slips through, because dividing by zero or inventing a negative batch is not a meaningful scale. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately send zero servings or empty lists. For catering, convert a pilot batch written for eight plates into a service count of forty-eight by sending original_servings eight and target_servings forty-eight so factor is derived automatically without a separate multiplier field.
Integration use cases
Resize a home recipe card for guests
Paste the numeric amounts from a four-serving pasta or cake formula, set original_servings to four and target_servings to six or two, and print the scaled list for shopping or mise en place.
Unit tests for meal-prep calculators
Generate known-good scaled arrays and deliberate non-positive input rejections for coding kata expected values and API contract tests.
Technical questions
Is the recipe portion scaler free?
Yes in the browser. Programmatic API calls cost $0.002 per successful request from prepaid KIT balance; invalid_input responses are not charged.