Cake flour grams to cups converter
This cake flour grams-to-cups converter turns a metric weight into US measuring cups with one fixed, transparent density: 114 grams of cake flour per cup.
Run — free
Enter any non-negative gram amount and receive a stable decimal result that is easy to use in a recipe, worksheet, or kitchen application. The conversion is deterministic, so the same input always produces the same answer. It is intended specifically for cake flour rather than all-purpose or bread flour, whose different densities would change the result.
Convert a cake flour weight into US cups
Start with the cake flour quantity written in grams and enter that number in the grams field. The converter divides the weight by 114, the fixed number of grams assigned to one US cup of cake flour. For example, a recipe quantity equal to two times that constant becomes two cups, while smaller or uneven weights produce a decimal cup value. The calculation accepts zero and positive finite numbers, including decimal weights when a scale provides them. It rejects negative amounts because a physical ingredient quantity cannot be below zero, and it rejects text or non-finite values rather than guessing what the author meant. The returned object includes the original gram amount, the calculated cups, and the density constant, making the arithmetic easy to audit. This narrow input contract is useful when a recipe, inventory record, or nutrition worksheet already identifies the ingredient as cake flour and only the measurement system needs to change. Use the decimal result directly when precision matters, or apply your preferred kitchen rounding afterward based on the measuring tools you have available.
Understand the fixed density behind the result
Volume and weight describe different properties, so converting grams to cups requires an assumed density. This capability deliberately uses 114 grams for one US cup of cake flour on every request. It does not inspect brands, humidity, storage conditions, sifting, compression, or the way a cup was filled. That fixed rule is what makes the function reproducible: identical gram values always return identical cup values, regardless of when or where the request runs. Cake flour is finer and is commonly measured at a different weight per cup than all-purpose or bread flour, which is why the result should not be reused for another flour type. A kitchen cup is also not a universal unit; this converter targets the US customary cup, not a metric cup or an informal drinking cup. The output is rounded to at most twelve decimal places to prevent distracting floating-point artifacts while preserving far more precision than ordinary kitchen measuring equipment can represent. Keeping the density in the response lets developers display the assumption beside the result and helps cooks understand why another chart may show a slightly different conversion.
Use the conversion responsibly in recipes and software
This conversion is most reliable as a practical recipe adaptation, not as a laboratory measurement of a particular bag of flour. If a recipe supplies grams, using a scale remains the most direct approach because weight avoids variation from scooping and packing. The cup result is helpful when no scale is available, when a US-volume version of a recipe is being drafted, or when an application needs a consistent display value. For kitchen use, compare the decimal answer with the markings on the available cup set and round only at the final step. Rounding the gram input before conversion and then rounding the cup result again can compound error, especially for small batches. For software use, preserve the numeric response and show the declared 114-grams-per-US-cup assumption near it instead of presenting the value as a universal physical truth. The function performs no network calls, stores no ingredient data, uses no random values, and reads no clock, which makes it suitable for repeatable tests and automated pipelines. API execution costs $0.002 per request, while the same pure calculation can support a browser experience without sending the entered measurement elsewhere.
What you can do with it
Adapt a metric baking recipe
Turn a cake flour weight from a gram-based recipe into US cups when only volume measures are available.
Build a recipe application
Provide a repeatable cake-flour conversion with an explicit density constant and stable numeric output.
Standardize a kitchen worksheet
Convert recorded cake flour weights into one consistent US-cup convention for planning and comparison.
FAQ
What density does the converter use?
It uses a fixed density of 114 grams of cake flour per US cup for every calculation.
How is the number of cups calculated?
The entered gram value is divided by 114, then the result is rounded to at most twelve decimal places for stable output.
Can I use this for all-purpose or bread flour?
No. Those flours have different grams-per-cup assumptions. This converter is intentionally specific to cake flour.
Does it accept negative or non-numeric input?
No. Negative, missing, non-numeric, and non-finite gram values return an invalid-input error.
Is this a metric cup conversion?
No. The output is in US customary cups, so it should not be interpreted as metric cups.
What does an API conversion cost?
Each API request costs $0.002.
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/cake-flour-grams-to-cups \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"grams":228}'const res = await fetch("https://api.kit.forhosting.com/cook/cake-flour-grams-to-cups", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"grams": 228
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/cook/cake-flour-grams-to-cups",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"grams": 228
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/cook/cake-flour-grams-to-cups", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"grams":228}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"grams":228}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/cook/cake-flour-grams-to-cups", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"grams": 228
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "cook.cake_flour_grams_to_cups",
"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. |