ForHosting KIT · Home, food & hobbies

Scale Recipe Ingredient Quantities by Serving Count

Going from 4 to 10 servings multiplies everything by 2.5: 300 g of flour becomes 750 g and 2 eggs become 5. Enter the recipe's servings, the servings you need and the ingredients, and every amount keeps its unit. 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
Original servings
4
Target servings
10
You get
Scale factor
2.5

This recipe serving scaler recalculates every ingredient quantity when the number of people, portions, or batches changes. Enter the recipe's original serving count, the serving count you need, and a structured list of ingredients. The calculator applies one proportional factor to every quantity, keeps ingredient names and units attached, and returns both the original and scaled values. It is deterministic, requires no network access, and rejects zero or negative serving counts before doing any arithmetic.

Scale a recipe without changing its proportions

A recipe is a set of proportions tied to an expected yield. If a soup written for four servings must feed ten people, increasing only the stock or only the vegetables changes the dish rather than resizing it. This calculator uses one scale factor for the entire ingredient list: target servings divided by original servings.

Every supplied quantity is multiplied by that same factor, so the relationship among flour, water, salt, oil, spices, and other ingredients remains mathematically consistent. Enter quantities as numbers and keep each unit in its own optional unit field. The result repeats the ingredient name, original quantity, scaled quantity, and unit, which makes it straightforward to display a before-and-after list or pass the records into another workflow.

Zero quantities are permitted because a recipe record may intentionally include an optional ingredient at none, but negative quantities are rejected as invalid recipe data. The calculation changes amounts only; it does not convert grams to cups, choose package sizes, or infer the density of an ingredient. Use consistent units in the input, and interpret the output in those same units.

Understand the serving factor and numeric result

Moving from four servings to ten produces a factor of 2.5, while moving from eight servings to two produces a factor of 0.25. Each original quantity is then multiplied by the factor. For example, 300 grams of flour in a four-serving recipe becomes 750 grams for ten servings, and two eggs become five.

Results are normalized to a stable numeric precision to avoid distracting floating-point artifacts such as a long trail of binary decimal digits. Both serving fields must be finite numbers greater than zero. Ingredient quantities must be finite, non-negative numbers.

The bounded list and quantity limits prevent accidental oversized requests while still allowing large catering recipes and detailed commercial formulas. No rounding to whole packages, spoon measures, or eggs is imposed; the caller decides whether practical kitchen rounding is appropriate.

Use scaled quantities in kitchens and software

For home cooking, enter the yield printed on the recipe and the number of diners expected, then copy the scaled list into a shopping note or preparation plan. For catering, the same response can become a production worksheet while retaining the units chosen by the kitchen. Preserve the unrounded numeric result until the presentation layer if your application has ingredient-specific display rules.

Liquids may be shown to one decimal place, spices to a smaller measure, and indivisible items such as eggs may require a deliberate operational decision. Those choices are outside proportional scaling and should not silently alter the calculation. A useful validation pattern is to confirm that the ingredient array is non-empty, each name is meaningful, every quantity uses the intended unit, and both serving counts are positive before submission.

When shrinking a recipe, also consider equipment constraints: mathematically correct quantities do not guarantee that a different pan size, cooking time, or mixer capacity will behave identically.

Resize dinner for more guests

Turn a four-serving recipe into quantities for ten diners while keeping every ingredient in proportion.

Prepare a catering production sheet

Scale a tested small-batch formula to the required event yield and retain names and units beside each result.

Add a serving selector to a recipe app

Recalculate structured ingredient records deterministically whenever a reader chooses a new serving count.

Does the calculator convert units?

No. It preserves the optional unit attached to each ingredient and scales only the numeric quantity.

Will eggs or package counts be rounded automatically?

No. The response preserves the proportional result. Your kitchen or application can apply an appropriate practical rounding rule afterward.

How is the scale factor worked out?

It is the servings you need divided by the servings in the recipe. For 10 people from a recipe for 4, the factor is 2.5, and every quantity is multiplied by it.

Can I scale a recipe down?

Yes. Going from 8 servings to 2 gives a factor of 0.25, so every quantity becomes a quarter of the original. The same rule works in both directions.

Why change every ingredient by the same factor?

Because a recipe is a set of proportions. If you increase only the stock or only the vegetables, you change the dish instead of resizing it, so flour, water, salt and spices all move together.

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/life/recipe-scale-servings

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/life/recipe-scale-servings \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"original_servings":4,"target_servings":10,"ingredients":[{"name":"flour","quantity":300,"unit":"g"},{"name":"eggs","quantity":2,"unit":"count"}]}'
{
  "original_servings": 4,
  "target_servings": 10,
  "ingredients": [
    {
      "name": "flour",
      "quantity": 300,
      "unit": "g"
    },
    {
      "name": "eggs",
      "quantity": 2,
      "unit": "count"
    }
  ]
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "life.recipe_scale_servings",
  "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.

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.

Understand the serving factor and numeric result

The scale factor is calculated as target_servings divided by original_servings. The response includes scale_factor so callers can audit the arithmetic or explain it in a user interface. A zero or negative original serving count cannot form a meaningful recipe baseline, and a zero or negative target would describe no usable batch, so either condition returns an invalid_input error.

Use scaled quantities in kitchens and software

Recipe applications can call the function whenever a user changes a serving selector, because the deterministic algorithm returns the same JSON for the same input and does not depend on network services, randomness, or the current time. API requests cost $0.002 per successful task, while invalid input is returned as a typed error.

How is each ingredient quantity scaled?

The calculator divides target_servings by original_servings, then multiplies every ingredient quantity by that scale factor.

What happens if a serving count is zero or negative?

The request returns an invalid_input error. Both original_servings and target_servings must be positive finite numbers.

How much does an API request cost?

Each successful API task costs $0.002. The browser tool runs locally, and invalid requests return a typed error.

Read the full KIT documentation →