Cocktail batch scaling calculator
Scaling a one-drink card to eight turns 60 ml of gin into 480 ml and 30 ml of lemon juice into 240 ml, with every line multiplied by the same factor. Enter the amounts, the recipe's yield and the drinks you need. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Amounts
- 60, 30, 15, 2
- Servings
- 1
- Target
- 8
- Names
- gin (ml), lemon juice (ml), simple syrup (ml), angostura (dashes)
- Scaled
- 480, 240, 120, 16
- Factor
- 8
- Quantity
- 4
A cocktail batch scaling calculator turns a single-serve or small-yield drink card into a pitcher or multi-glass prep list without rewriting ratios by hand. Enter each numeric amount from the recipe—spirit, citrus, sweetener, bitters—plus the original serving count and the number of drinks you need tonight. The tool computes factor equals target divided by servings and multiplies every line by that shared factor so the gin-to-vermouth balance stays identical when you go from one coupe to eight, or from a two-drink test batch to a forty-glass reception. Optional ingredient labels travel with each amount so the response can show gin millilitres next to lemon juice and dashes of bitters.
What cocktail batch scaling means and why ratios stay fixed
Bartenders, home hosts, and event caterers face the same arithmetic problem: a published cocktail lists fixed millilitres or ounces for one or two drinks, but service needs a different yield. Batch scaling multiplies every scalable amount by one shared factor so relative ratios stay constant—twice the spirit still meets twice the citrus at the same balance, and bitters scale with the same coefficient even when the unit is dashes instead of millilitres.
This cocktail batch scaling calculator accepts a non-empty list of finite numbers as amounts, a strictly positive original servings value, and a strictly positive target serving count. It sets factor equal to target divided by servings, then returns both a flat scaled array and an ingredients array that pairs each original amount with its scaled value. Units are not converted here; sixty stays sixty until you decide whether it is millilitres or ounces, and the scaled result keeps the same unit convention you already used on the card.
That separation is intentional: volume converters and proof calculators solve other questions, while this capability only answers how much of each listed line you need after the guest count changes. Search intent for a cocktail batch scaling calculator is distinct from a generic kitchen recipe scaler: people looking for pitcher prep, wedding bar lists, and single-drink-to-batch conversion want cocktail language, drink yields, and spirit-line examples on the landing page.
Practical tips for parties, bars, limits, and related tools
When scaling a classic single-serve card, set servings to one and target to the number of glasses you plan to pour—eight for a dinner party, twenty-four for a small reception. For a recipe already written as a two-drink shake, set servings to two and target to the full service count so factor is derived correctly without double-counting. Near-zero positive values are allowed for tiny bitter lines if your card uses them, but zero original or target servings are always rejected.
This landing targets people searching for a cocktail batch scaling calculator, scale cocktail recipe for a party, or pitcher drink multiplier; it is not a unit converter, not an ABV estimator, and not a full bar inventory system. 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.
What you can do with it
Dinner-party pitcher from a single-serve card
Paste gin, citrus, and syrup millilitres from a one-drink recipe, set servings to 1 and target to 8, and print the scaled list for a shared pitcher.
Wedding or reception bar batch lists
Convert a two-drink test shake into a forty-glass service by sending servings 2 and target 40 so every spirit and modifier scales by twenty.
FAQ
How does the cocktail batch scaling calculator work?
It multiplies every amount by factor = target ÷ servings. Provide original servings and a positive target drink count, plus the numeric ingredient amounts (optional names for labels).
What happens if servings or target is zero or negative?
Non-positive original or target servings cannot define a proportional cocktail batch scale.
Can I scale a recipe written for two drinks up to a large party?
Yes. Set servings to 2 and target to the full glass count. Factor becomes target ÷ 2 and every ingredient multiplies by that value.
Does this convert ounces to millilitres?
No. It only scales numbers. Keep units consistent yourself, or convert units first, then scale the resulting amounts.
Is the cocktail batch scaling calculator free?
The browser tool is free and runs locally.
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/cocktail-scale \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"amounts":[60,30,15,2],"servings":1,"target":8}'const res = await fetch("https://api.kit.forhosting.com/cook/cocktail-scale", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"amounts": [
60,
30,
15,
2
],
"servings": 1,
"target": 8
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/cook/cocktail-scale",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"amounts": [
60,
30,
15,
2
],
"servings": 1,
"target": 8
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/cook/cocktail-scale", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"amounts":[60,30,15,2],"servings":1,"target":8}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"amounts":[60,30,15,2],"servings":1,"target":8}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/cook/cocktail-scale", 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": [
60,
30,
15,
2
],
"servings": 1,
"target": 8
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "cook.cocktail_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.
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 original or target servings fail with invalid_input because a zero or negative yield cannot define a meaningful scale.
What cocktail batch scaling means and why ratios stay fixed
Classroom worksheets, bar-program spreadsheets, 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: inputs, response shape, and validation
Optional names appear at the top level only when at least one label was provided; optional fields are omitted rather than set to null. Prefer numbers rather than pre-formatted unit strings inside amounts; put units in the optional names field instead so sixty and gin (ml) stay separate and machine-readable. Send a JSON body with amounts as a required array of finite numbers—or a comma-separated string on text forms—plus servings for the original yield and target for the desired drink count. Both servings and target must be finite and strictly greater than zero; zero, negative, and non-numeric values fail with invalid_input and are never charged. Optional names (aliases labels, ingredients) align string labels with each amount in the same order; extra or missing labels are padded or truncated so the row count always matches. Absolute values must stay within one trillion, and the list length is capped so a Worker can finish quickly. On success the response echoes rounded amounts, scaled values, factor, count, servings, target, ingredients rows with index amount and scaled plus name when present, formula, message, and ordered steps. Failed validation—empty amounts, non-finite numbers, missing servings or target, or non-positive servings—returns invalid_input. Pricing is a flat $0.002 per successful request with unit item.
Practical tips for parties, bars, limits, and related tools
Always reject non-positive servings in client forms before submit when you can; the API will still throw a clear invalid_input message if zero or a negative guest count slips through, because dividing by a non-positive yield or targeting zero drinks is not a meaningful batch. Keep units consistent across the list: if spirit lines are millilitres, keep citrus and syrup in millilitres too, and put dashes or pieces only on lines that truly use those units. Prefer sibling cook tools when you need general kitchen recipe scaling or cost per serving, then use this endpoint when the intent is cocktail yield. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately send target zero.
Integration use cases
Unit tests for bar-program calculators
Generate known-good scaled arrays and deliberate non-positive servings rejections for coding kata expected values and API contract tests.