Flour cups to grams converter
Two cups of all-purpose flour weigh 240 g, but bread and cake flour do not: each type has its own density of 120, 127 or 114 g per cup. Pick the flour, enter cups or grams, and convert either way. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Numeric quantity to convert
- 2
- Flour variety: all-purpose
- all-purpose
- From
- cups
- To
- grams
- Result
- 240
- Flour label
- all-purpose
- G per cup
- 120
- Direction
- cups → grams
A flour cups to grams converter turns a volumetric kitchen measure into the weight your digital scale actually needs—or the reverse when a metric recipe lists grams and your only tool is a measuring cup. Enter how many cups or grams of flour you have, pick the flour type—all-purpose at one hundred twenty grams per cup, bread flour at one hundred twenty-seven, or cake flour at one hundred fourteen—and choose the target unit; the tool returns the converted value, the exact grams-per-cup density for that flour, a short formula line, and ordered substitution steps you can copy into a test or worksheet.
Why flour type changes grams per cup
A cup of flour is not a single universal weight. All-purpose flour, the everyday white flour in most US pantries, is commonly taken as one hundred twenty grams per leveled US cup when spooned into the cup and leveled with a straight edge—the density this converter locks in for the all-purpose type.
Bread flour is slightly denser at one hundred twenty-seven grams per cup because higher protein and a coarser mill grind pack more mass into the same volume, which matters when you scale a lean dough or a sandwich loaf from cups into grams. Cake flour is lighter at one hundred fourteen grams per cup: finer milling and lower protein leave more air in a leveled cup, so one cup of cake flour weighs less than one cup of bread flour even when both are measured the same way.
If you convert without naming the flour type, a cake can come out dry, a bread can underhydrate, or a cookie dough can spread wrong by tens of grams per cup. Teachers, recipe importers, and automated graders can therefore assert exact numbers: two cups of all-purpose become two hundred forty grams, two cups of bread flour become two hundred fifty-four grams, and two cups of cake flour become two hundred twenty-eight grams, each with the same formula shape and no hidden rounding until the shared twelve-decimal publish step.
Practical tips, limits, and related searches
Always pick the flour type that matches the recipe’s ingredient list or the bag in your pantry: all-purpose for everyday baking, bread for yeast breads and pizza, and cake for tender cakes and soft cookies that specify cake flour. Prefer sending numbers rather than pre-formatted strings when you control the client; string numbers are accepted only when they match a strict finite numeric pattern.
When teaching or writing tests, pair examples across flour types with the same cup count—two cups under each type—to show how result grams diverge while the formula stays identical. This landing targets people searching for a flour cups to grams converter, all-purpose flour weight, bread flour grams per cup, or cake flour cups to grams online; it is not a general volume converter for tablespoons and milliliters, not a sugar or cocoa density tool, and not a whole-wheat or gluten-free flour calculator.
Prefer this capability when you already know the flour variety and only need cups versus grams; if your source uses tablespoons of flour, convert volume first with a dedicated spoon tool, then map residual cups here if needed. Round-trip checks are easy: convert cups to grams and back with the same flour type and confirm you recover the original amount within twelve-decimal rounding, and confirm that switching only the type from all-purpose to cake changes a one-cup result from one hundred twenty grams to one hundred fourteen.
What you can do with it
Scale cup recipes onto a kitchen scale
Home bakers convert all-purpose, bread, or cake flour from cups into grams so a digital scale can follow a US recipe without packing or scooping variance.
Classroom demos of flour density
Teachers show how two cups of flour weigh differently for all-purpose, bread, and cake while the conversion formula stays a single multiply or divide by a fixed density.
FAQ
Can I convert grams back to cups?
Yes. Set from to grams and to to cups with the same flour type; the result is amount divided by that type’s grams-per-cup density.
Does this convert whole-wheat or gluten-free flour?
No. It only converts all-purpose, bread, and cake flour between cups and grams under fixed densities. Use a dedicated tool or manufacturer data for other flours.
Is the flour cups to grams converter free?
The browser tool is free and runs locally.
Why does a cup of cake flour weigh less than a cup of bread flour?
Cake flour is milled finer and has less protein, so a leveled cup holds more air and weighs 114 g. Bread flour packs more mass into the same cup, 127 g, because of its higher protein and coarser grind.
Which flour type should I choose?
Choose the one named in the recipe or printed on your bag: all-purpose for everyday baking, bread flour for yeast breads and pizza, and cake flour for tender cakes and soft cookies that call for it.
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/flour \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"amount":2,"flour_type":"all-purpose","from":"cups","to":"grams"}'const res = await fetch("https://api.kit.forhosting.com/cook/flour", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"amount": 2,
"flour_type": "all-purpose",
"from": "cups",
"to": "grams"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/cook/flour",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"amount": 2,
"flour_type": "all-purpose",
"from": "cups",
"to": "grams"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/cook/flour", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"amount":2,"flour_type":"all-purpose","from":"cups","to":"grams"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"amount":2,"flour_type":"all-purpose","from":"cups","to":"grams"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/cook/flour", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"amount": 2,
"flour_type": "all-purpose",
"from": "cups",
"to": "grams"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "cook.flour",
"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.
Limits
max_abs | 1000000000000 |
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 flour types are rejected with a clear invalid_input error instead of silently assuming all-purpose, so a typo or unsupported variety never becomes a wrong dough hydration.
Why flour type changes grams per cup
This converter forces an explicit flour type on every call, applies one fixed density, and never invents a fourth variety.
How to call the API and what comes back
Accepted flour tokens include all-purpose, ap, plain, bread, strong, cake, pastry, and compact forms such as bread flour or cake flour; accepted unit tokens include cup, cups, g, gram, and grams. Send a JSON body with four required fields: amount (aliases value, qty, quantity, n)—a finite number whose absolute value stays within one trillion—flour_type (aliases type, flour, kind, variety) naming the flour variety, from (aliases from_unit, unit_from, source) as cups or grams, and to (aliases to_unit, unit_to, target) as cups or grams. On success the response echoes rounded amount, the canonical flour_type id and flour_label, from and to, result as the converted number, g_per_cup as the density for that flour, formula describing multiply or divide by the density (or identity when units match), direction as a short from-arrow-to string, message as an English summary, and steps as an ordered array of substitution lines. Converting cups to grams multiplies amount by g_per_cup; converting grams to cups divides by the same density; when from equals to the amount is returned unchanged but the density is still reported so callers can log the flour standard they used. Failed validation—missing fields, non-finite numbers, values outside absolute limits, an unknown flour type, or an unknown unit—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, limits, and related searches
Keep absolute amounts inside the published trillion limit so intermediate products stay finite in IEEE double precision on the Worker and in the browser. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when you deliberately send an unknown flour type such as rye to verify error handling.
Integration use cases
Deterministic tests for recipe apps
Developers generate golden cups↔grams pairs for each flour type, plus deliberate unknown-type rejections, for unit tests and CI fixtures.
Technical questions
How many grams are in one cup of flour?
It depends on the flour type: all-purpose is 120 g per cup, bread flour is 127 g per cup, and cake flour is 114 g per cup. This tool requires you to choose the type so the answer is unambiguous.
What happens if I send an unknown flour type?
The API returns invalid_input naming the unsupported flour type. Only all-purpose, bread, and cake (plus documented aliases) are accepted.