Whole wheat flour cups to grams converter
1.5 cups of whole wheat flour weigh 180 grams, at a fixed 120 g per US cup. Type the cups from an American recipe and get a metric weight for your bread dough or shopping list that is the same every time. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Cups
- 1.5
- Grams
- 180
- Grams per us cup
- 120
This whole wheat flour cups-to-grams converter turns a volume measurement into a repeatable metric weight using a fixed factor of 120 grams per US cup. Enter any finite, non-negative number of cups, including a decimal for a partial cup, and receive the corresponding grams immediately. The calculation is deterministic: identical input always produces identical output. It is useful when adapting American recipes, preparing a shopping list, scaling a bread formula, or recording ingredients in a system that expects metric weights rather than kitchen volume measures.
Enter the amount in US cups
Provide the quantity of whole wheat flour exactly as it appears in the recipe, expressed in US cups. Whole numbers and decimal fractions are accepted, so values such as 1, 0.5, 1.25, and 2.75 work directly. A value of zero is valid and returns zero grams.
Negative quantities are rejected because they do not represent a usable ingredient amount, while text, missing values, NaN, and infinity are rejected to keep the result unambiguous. The input refers specifically to a US customary cup, not an imperial cup, a metric cup, or an unmarked drinking vessel. If a recipe uses a mixed number, convert its fractional part to a decimal before submitting it: one and one-half cups becomes 1.5, while two and one-quarter cups becomes 2.25.
No ingredient selector is needed because this capability is deliberately dedicated to whole wheat flour. That narrow contract makes automated calls simple and prevents an accidental density choice from silently changing the answer. The response repeats the accepted cup quantity, making it easy to associate the output with the original recipe line.
Understand the fixed conversion
The converter multiplies cups by a fixed density constant of 120 grams for each US cup of whole wheat flour. For example, 1.5 cups is calculated as 1.5 multiplied by 120, producing 180 grams. This is an ingredient-specific culinary conversion rather than a universal relationship between volume and mass.
A cup of water, sugar, butter, or another flour can weigh a different amount, so this result should only be used for whole wheat flour. The algorithm has no network requests, random values, clock access, stored state, or model inference. The fixed constant also means the converter does not attempt to infer milling fineness, wheat variety, humidity, sifting, packing, or measuring technique.
Those real-world conditions can change the physical weight of a cup, but they are intentionally outside this deterministic conversion contract.
Use the result appropriately
Use the gram result when translating a US recipe for a metric kitchen scale, scaling ingredient quantities, estimating how much flour to purchase, or normalizing recipe data before storage. Weighing flour is often more repeatable than scooping it because volume measurements can vary with settling and packing. Still, this tool is a consistent reference conversion, not a measurement of the flour physically in your container.
When precision matters, especially for commercial production or a carefully tested baker's formula, follow the recipe author's stated gram weight if one is supplied. That author-specific value should take priority because it reflects the flour and measuring method used during recipe development. If no weight is supplied, the fixed 120-gram factor provides a clear and reproducible assumption.
Keep the returned density with the converted value in audit-sensitive workflows so another person can reconstruct the calculation later. Do not use this result for other flour types merely because their names sound similar; dedicated ingredient conversions preserve the intended density and make recipe transformations easier to review.
What you can do with it
Convert an American recipe
Turn a whole wheat flour quantity written in US cups into grams for a metric kitchen scale.
Scale a bread formula
Convert the original cup amount before multiplying a recipe for a larger or smaller batch.
Normalize recipe data
Store whole wheat flour amounts in grams while retaining the fixed conversion factor for reproducibility.
FAQ
What conversion factor does this use?
It uses a fixed value of 120 grams per US cup of whole wheat flour.
Can I enter a fraction of a cup?
Yes. Enter it as a decimal number, such as 0.5 for one-half cup or 1.25 for one and one-quarter cups.
Can I use the result for another flour?
No. The constant is specifically for whole wheat flour; other ingredients and flour varieties can have different cup weights.
Does sifting or packing the flour change the result?
No. The converter always uses 120 grams per US cup and does not try to account for milling fineness, wheat variety, humidity, sifting, packing or how the cup was filled.
Which cup size does the converter assume?
A US customary cup. It is not an imperial cup, a metric cup or a drinking mug, so check that your recipe is American before converting its cups to grams.
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/whole-wheat-flour-cups-to-grams \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"cups":1.5}'const res = await fetch("https://api.kit.forhosting.com/cook/whole-wheat-flour-cups-to-grams", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"cups": 1.5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/cook/whole-wheat-flour-cups-to-grams",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"cups": 1.5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/cook/whole-wheat-flour-cups-to-grams", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"cups":1.5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"cups":1.5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/cook/whole-wheat-flour-cups-to-grams", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"cups": 1.5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "cook.whole_wheat_flour_cups_to_grams",
"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
Enter the amount in US cups
For API use, send the number in the cups field.
Understand the fixed conversion
The response includes grams_per_us_cup alongside the result so an integration can record which constant produced the answer. Consequently, the same numeric input always yields the same JSON result, regardless of when or where it runs.
Use the result appropriately
The API costs $0.002 per request and performs one conversion per item. Applications can validate input locally as well, but they should still handle invalid_input responses for negative or non-numeric values.
Technical questions
Does it accept negative amounts?
No. Negative quantities return an invalid_input error because ingredient amounts must be non-negative.
How much does an API conversion cost?
Each API request costs $0.002.