ForHosting KIT · Home, food & hobbies

Recipe scaler

Multiply every line of an ingredient list by the same number: doubling 250 g of flour, 100 g of sugar, 2 eggs and 1 teaspoon of salt gives 500, 200, 4 and 2, and 4 servings to 6 is a factor of 1.5. Free in your browser.

  • Free
  • Runs in your browser
  • No sign-up
  • Your data stays on your device
Use it from WebAPIEmailTelegramApp soon
If you enter
Amounts
250, 100, 2, 1
Factor
2
Names
flour (g), sugar (g), eggs, salt (tsp)
You get
Scaled
500, 200, 4, 2
Quantity
4
Calculation mode
multiplier

A recipe 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 amounts as a list of numbers, then either supply a direct multiplier—double is two, half is zero point five—or give an original serving count and a target serving count so the tool derives factor equals target divided by servings. Optional name labels stay aligned with each amount so the response can echo flour, sugar, and salt next to the new figures.

What recipe scaling means and when to use a multiplier

Home cooks, meal-prep services, 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. 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. A direct multiplier is the simplest control: set factor to two for a double batch, to three for a triple, or to zero point five for a half recipe.

The tool accepts a non-empty list of finite numbers as amounts, optional parallel names for labels, and returns both a flat scaled array and an ingredients array that pairs each original amount with its scaled value. 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.

Practical tips, zero-factor errors, limits, and related searches

When scaling by servings, keep the original count non-zero—four to six is a common path and yields factor one point five—and remember that servings defaults to one when only target is sent, which is useful for recipes written per person. Prefer numbers rather than pre-formatted unit strings inside amounts; put units in the optional names field instead so two hundred fifty and flour (g) stay separate. Near-zero factors after floating noise are treated as zero and rejected with the same rule, protecting callers from accidental wipe-outs.

This landing targets people searching for a recipe scaler, scale recipe ingredients, or servings multiplier calculator; it is not a unit converter, not a nutrition estimator, and not a full meal planner. Prefer sibling cook 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 factor scales every line proportionally.

Double or half a home recipe card

Paste the numeric amounts from a four-serving pasta or cake formula, set factor to two or zero point five, and print the scaled list for shopping or mise en place.

Catering yield from test-kitchen batches

Convert a pilot batch written for eight plates into a service count of forty-eight by sending servings and target so factor is derived automatically.

How does the recipe scaler work?

It multiplies every amount by one factor. Optional names stay aligned with each line.

What happens if the factor is zero?

A factor of zero would zero every ingredient and is rejected on purpose.

Can I scale by servings instead of a raw multiplier?

Yes. Send target and optionally servings (default 1).

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.

Is the recipe scaler free?

The browser tool is free and runs locally.

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.

POSThttps://api.kit.forhosting.com/cook/recipe-scale

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.

curl -X POST https://api.kit.forhosting.com/cook/recipe-scale \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amounts":[250,100,2,1],"factor":2}'
{
  "amounts": [
    250,
    100,
    2,
    1
  ],
  "factor": 2
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "cook.recipe_scale",
  "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.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

max_abs1000000000000
max_n10000
HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

A factor of zero is rejected with invalid_input because zeroing every line would erase the recipe rather than scale it.

What recipe scaling means and when to use a multiplier

Classroom worksheets and coding kata can assert the same rounded JSON because the arithmetic never depends on the clock or on external data.

How to call the API: factor mode, servings mode, and the response

If both factor and target appear, the explicit factor wins so scripts that already computed the ratio are not overridden. Send a JSON body with amounts as a required array of finite numbers—or a comma-separated string on text forms—plus either factor or target under the published require-one-of rule. Factor (aliases multiplier, scale, times) is the explicit scale coefficient applied to every amount. Target (aliases to_servings, target_servings, for) is a desired serving count; when you use target without factor, the solver sets factor equals target divided by servings, and servings defaults to one if you omit the original count. Absolute values must 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, factor, count, mode (multiplier or servings), optional servings and target, names, ingredients rows, formula, message, and ordered steps. Failed validation—empty amounts, non-finite numbers, missing factor and target, a zero original servings divisor, or a factor of zero—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item and zero marginal unit price.

Practical tips, zero-factor errors, limits, and related searches

Always reject a factor of zero in client forms before submit when you can; the API will still throw a clear invalid_input message if zero slips through, because zeroing every ingredient 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 factor zero.

Unit tests for meal-prep calculators

Generate known-good scaled arrays and deliberate factor-zero rejections for coding kata expected values and API contract tests.

Read the full KIT documentation →