Grain to water ratio lookup
One cup of quinoa needs two cups of water and about 15 minutes of covered simmering. Type a grain, from barley and farro to bulgur or teff, add the dry amount if you like, and get the water for the whole pot by volume. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Grain
- quinoa cup
- Grain amount
- 1
- Grain key
- quinoa cup
- Water ratio
- 2
- Ratio label
- 1:2
- Grain parts
- 1
Home cooks, meal-prep services, and recipe engines constantly need the right water volume for dry grains, yet package directions disagree and memory fails under time pressure. Quinoa usually wants two parts water, pearl barley closer to three, farro often two and a half — and the wrong ratio turns a side dish into mush or undercooked grit. This grain to water ratio lookup accepts a grain name, returns the fixed absorption ratio as water parts per one part dry grain by volume, and optionally multiplies by a grain amount so apps can scale a batch without inventing their own table.
What the grain-to-water ratio means in the kitchen
Absorption cooking means you combine a measured volume of dry grain with a measured volume of liquid, bring to a simmer, cover, and wait until the liquid is taken up and the kernels are tender. The water ratio is therefore a pure volume relationship: if the table says two, one cup of dry grain needs two cups of water; if it says two and a half, one cup needs two and a half cups.
That relationship holds whether you measure in cups, milliliters, or scoops, as long as grain and water share the same volume unit. Ratios are rules of thumb for covered absorption — not pasta-style boiling in excess water — so risotto-style constant stirring or rice cookers with their own firmware may still differ. Typical simmer minutes are included as a guide for planning, not a hard stop, because altitude, age of grain, and pot tightness change doneness.
Rinsing quinoa or toasting millet before adding water does not change the table ratio; it only changes flavor and soapiness.
Where a fixed water ratio helps most
Recipe websites and meal-kit apps need a single source of truth for side-dish grain pots so editors stop pasting conflicting cup counts from different blogs. Smart kitchen displays and voice assistants answer how much water for one cup of quinoa without calling a large language model that might invent a ratio. Nutrition and macro trackers that already store dry grain grams can still use volume ratios for the cook step while keeping weight-based macros separate.
Failed validation does not consume balance. Keep the grain vocabulary stable in your product copy, document that ratios are absorption volume guides, and you get reproducible kitchen math for home cooks, CMS blocks, and edge workers without hosting your own grain spreadsheet.
What you can do with it
Smart kitchen and voice assistants
Answer how much water for a named grain with a deterministic table lookup instead of an unpredictable free-text model guess.
FAQ
How do I scale water for a batch?
Optional unit only labels the message; it does not convert units.
What happens if the grain is unknown?
Unknown grains are not billed and never invent a ratio.
Are these ratios by weight or by volume?
Use the same cup, scoop, or milliliter measure for both grain and water.
Is the simmer time exact?
No, it is a planning guide. Altitude, the age of the grain and how tightly the lid fits all change when the kernels are tender, so taste near the end instead of stopping at the minute shown.
Does rinsing or toasting the grain change the water?
No. Rinsing quinoa or toasting millet changes the flavor and, for quinoa, the soapy taste, but the water ratio stays the same. The ratios are for covered absorption cooking, not for boiling in plenty of water.
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/grain-water-ratio \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"grain":"quinoa"}'const res = await fetch("https://api.kit.forhosting.com/cook/grain-water-ratio", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"grain": "quinoa"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/cook/grain-water-ratio",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"grain": "quinoa"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/cook/grain-water-ratio", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"grain":"quinoa"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"grain":"quinoa"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/cook/grain-water-ratio", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"grain": "quinoa"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "cook.grain_water_ratio",
"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
Unknown grains fail cleanly with invalid_input instead of guessing.
What the grain-to-water ratio means in the kitchen
This capability encodes those common stovetop ratios for quinoa, barley, farro, white and brown rice, basmati and jasmine, wild rice, bulgur, couscous, millet, amaranth, buckwheat, freekeh, spelt, wheat berries, rolled and steel-cut oats, polenta, kamut, teff, sorghum, and rye berries, plus everyday aliases such as pearl barley, rolled oats, and cornmeal for polenta. When you need a scaled batch, pass grain_amount and the tool multiplies water by the same ratio so a two-cup pot and a ten-cup catering tray stay proportional.
Input contract, response fields, and error behaviour
Pin these deterministic numbers in tests so recipe apps and browser widgets stay byte-stable across releases. POST a JSON body with required string field grain — a known name such as quinoa, barley, or farro. Matching is case-insensitive; spaces, hyphens, and underscores are normalized, and aliases like pearl barley, brown rice, and steel-cut oats resolve to the same rows as their canonical keys. Optional grain_amount is a finite positive number in whatever volume unit you use for dry grain; when present, water_amount equals grain_amount times water_ratio. Optional unit is a short display label (cup, ml, liter) echoed in the message only — the API never converts between unit systems. On success the body includes grain as a human display name, grain_key as the stable snake_case identifier, water_ratio and water_parts as the numeric parts of water per one part grain, ratio_label such as 1:2, grain_parts always one, cook_minutes as a typical simmer guide, formula restating the scale rule, and message for UI copy. grain_amount, water_amount, and unit appear only when you supplied them, so clients that omit optional fields never see null placeholders. Missing grain, empty strings, unknown names, zero or negative grain_amount, and non-numeric amounts fail with invalid_input and are not billed. Example: grain quinoa returns water_ratio two and ratio_label 1:2; the same grain with grain_amount one and unit cup yields water_amount two cup. Example: grain farro yields water_ratio two point five; grain barley yields three.
Where a grain water ratio API earns its keep
Food-service prep sheets scale farro or barley for banquets by sending grain_amount and printing water_amount next to the bin label.
Integration use cases
Recipe sites and meal-kit apps
Resolve quinoa, barley, or farro to a fixed water ratio and scale water_amount from dry grain volume so published recipes stay consistent.
Food-service batch prep
Multiply grain_amount by water_ratio for catering trays and print stable water volumes on prep sheets without spreadsheet drift.
Technical questions
How do I look up the water ratio for quinoa, barley, or farro?
Send field grain with the name (case-insensitive). The API returns water_ratio and ratio_label such as 1:2 for quinoa, 1:3 for barley, and 1:2.5 for farro, plus typical cook_minutes.
What does the grain to water ratio lookup cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.