Grams to cups converter
250 g of all-purpose flour is 2 US cups, because flour is set at 125 g per cup. Enter the grams and pick the ingredient, from sugar and butter to honey or oats, and get the cups with the density behind them. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Grams
- 250
- Ingredient
- flour
- Ingredient label
- all-purpose flour US cup
- Grams per cup
- 125
- Cups
- 2
Home bakers and recipe apps constantly face the same mismatch: European and professional formulas list flour, sugar, and butter in grams, while many North American pans and measuring cups still speak in cup volume. Grams to cups is not a single constant conversion because a cup of flour packs differently from a cup of honey or a cup of rolled oats. This capability converts a mass in grams into US cups for a chosen common ingredient using a fixed density table of grams per cup, so the same inputs always return the same cups value with no network lookup and no random packing guess. You send grams and an ingredient name; the engine divides by the table density and returns cups, the grams-per-cup factor used, and a clear label for display. Unknown ingredients fail with invalid input instead of silently pretending everything behaves like water.
Why grams to cups needs an ingredient density table
Mass and volume only align through density. Water is close to one gram per millilitre, so roughly two hundred thirty-seven grams fill one US customary cup, but flour is aerated and compressible, granulated sugar is denser, and honey is much heavier per cup than either dry good. A generic grams-to-millilitres calculator without an ingredient key therefore misleads bakers who scale a metric cookie dough into cup measures or who reverse-engineer a US recipe into a kitchen scale workflow.
This product keeps a published fixed table of conventional cooking packing densities expressed as grams per US cup for flours, sugars, fats, dairy, oils, sweeteners, grains, cocoa, salt, and similar pantry staples. The conversion is simply cups equals grams divided by grams per cup for the resolved ingredient key. Negative grams and missing fields are rejected as invalid input, and zero grams correctly yields zero cups for empty optional ingredients in generated shopping lists.
Everyday baking uses and limits
Use the free in-browser grams to cups converter when scaling a single recipe at the counter, checking a blog post that mixes metric and cup measures, or teaching students why packing density matters in culinary math. Remember that cup packing varies with scooping technique and brand; the fixed table is a conventional shared baseline for software consistency, not a laboratory assay of every bag of flour.
Authors shipping SDKs can map the response into a two-column UI of grams and cups with the ingredient label as the row title, matching how home cooks already think about pantry conversions on paper.
What you can do with it
Scale metric recipes into cup measures
Bakers convert flour, sugar, and butter listed in grams into US cups for home cooks who only have measuring cups, using the ingredient-specific density so results stay consistent.
FAQ
Why is the result different for sugar and flour?
Each ingredient has its own grams-per-cup packing density. The engine divides grams by that table value, so denser foods yield fewer cups for the same mass.
Is the grams to cups converter free?
The browser tool runs free on your device.
Which cup definition do you use?
Results are in US cups. Densities are conventional cooking grams-per-cup values for US cup measures, not metric cups or pure SI density without packing.
What if my ingredient is not in the table?
It is rejected with a clear message instead of being treated like water. Water fills a cup at about 237 g, but flour, sugar and honey pack very differently, so guessing would give the wrong number of cups.
Why does my own scooped cup weigh a little differently?
Because packing varies with scooping technique and brand. The fixed table is a shared, conventional baseline so recipes stay consistent, not a lab measurement of every bag of flour you buy.
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/grams-cups \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"grams":250,"ingredient":"flour"}'const res = await fetch("https://api.kit.forhosting.com/cook/grams-cups", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"grams": 250,
"ingredient": "flour"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/cook/grams-cups",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"grams": 250,
"ingredient": "flour"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/cook/grams-cups", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"grams":250,"ingredient":"flour"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"grams":250,"ingredient":"flour"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/cook/grams-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": 250,
"ingredient": "flour"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "cook.grams_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. |
Technical notes
Why grams to cups needs an ingredient density table
Case-insensitive names, spaces, hyphens, and common synonyms such as white sugar or all-purpose flour normalize to the same canonical keys so form UIs stay friendly while the JSON contract stays stable.
How to call the converter and read the response fields
Non-finite masses, empty ingredient strings, and missing required fields follow the same error path. Send a JSON body with the required number field grams set to a non-negative finite mass, and the required string field ingredient naming a supported pantry item. Aliases g, mass, amount, and weight are accepted for the mass field; food, item, and name are accepted for the ingredient field when your client already uses those labels. Use cups alone when a simple display is enough; use grams_per_cup when you want to show users why honey and flour diverge; use ingredient_label when rendering multi-language shells that still need English kitchen names for the English landing. An unknown ingredient such as unicorn dust or a typo that does not match any alias fails with invalid_input and is not charged after validation rejects the request.
Practical baking workflows, limits, and API pricing
Use the prepaid API when a meal-planning app, smart scale companion, recipe CMS, or localization pipeline must convert many lines under a stable KIT contract at $0.002 per successful item. Pair this endpoint with pure mass-unit converters when you only need grains versus grams without volume, or with volume tools when the next step is millilitres rather than cups.
Integration use cases
Recipe apps and CMS importers
Content pipelines normalize mixed unit blog recipes into structured JSON with grams and cups side by side without embedding a live nutrition API.
Culinary classrooms and homework checks
Students practice density-aware kitchen math; graders pin expected cups for known ingredients and expect invalid_input on unknown foods.
Technical questions
How do I convert grams to cups for flour?
Send JSON with grams set to the mass (for example 250) and ingredient set to flour or all_purpose_flour. The response returns cups using the fixed flour density from the table.
What happens if the ingredient is unknown?
The request fails with invalid_input. Only ingredients present in the fixed density table (and their documented aliases) are accepted; unknown names are not charged after validation fails.