Rice cups to grams converter
One cup of raw white rice weighs 185 g and one cup of cooked rice 158 g, so this converter asks which one you have before turning cups into grams or grams back into cups. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Amount
- 1
- State
- raw
- Result
- 185
- From
- cups
- To
- grams
- State label
- raw (uncooked) rice
Home cooks, meal-prep apps, and recipe importers constantly meet rice measured two ways: a dry cup scooped from the bag, or a gram weight on a digital scale, and those two numbers only make sense when you also know whether the rice is raw or already cooked. One cup of uncooked white rice packs near one hundred eighty-five grams, while a cup of cooked rice sits near one hundred fifty-eight grams on the same US cup measure, so swapping densities without naming the state quietly ruins portions, macros, and shopping lists. This capability converts rice between cups and grams with a fixed density for each state, so the same amount and state always return the same result with no network lookup and no random packing guess. You send a non-negative amount, a state of raw or cooked, and optionally whether the amount is already in cups or grams; the engine multiplies or divides by the published grams-per-cup factor and returns both units plus a clear state label. Unknown rice states fail with invalid input instead of silently assuming dry rice.
Why rice cups to grams needs raw versus cooked density
Mass and volume for rice only line up when you name the physical state of the grain. Dry uncooked rice is dense and free-flowing; conventional kitchen tables list about one hundred eighty-five grams in one US customary cup. Once rice is boiled or steamed, water swells each grain and the cooked portion that fills the same cup is lighter on the scale in packing terms used by many converters—about one hundred fifty-eight grams per cup here.
Treating every rice cup as the same mass is how a meal plan over-orders dry rice or under-reports cooked portions on a nutrition label. This product keeps a published fixed table of those two densities and never invents a third grain variety on the fly. Conversion is simply grams equals cups times grams per cup for the resolved state, or the reverse divide when the source is already in grams.
Negative amounts and missing fields are rejected as invalid input, and zero correctly yields zero in both units for empty optional lines in generated shopping lists or step templates.
Everyday kitchen uses and what it leaves out
Use the free in-browser rice cups to grams converter when scaling a single recipe at the counter, checking a blog post that mixes dry-cup language with scale weights, or teaching students why cooked rice and raw rice do not share one density. Remember that brown rice, sushi rice, and wild rice can pack slightly differently in real kitchens; this tool uses fixed white-rice kitchen densities for raw and cooked states and does not model water-absorption yield ratios beyond those two packing numbers.
Authors shipping SDKs can map the response into a two-column UI of cups and grams with the state label as the row subtitle, matching how home cooks already compare bag labels and cooked leftovers on paper.
What you can do with it
Scale dry rice portions onto a kitchen scale
Convert recipe cups of raw rice into grams so a digital scale matches the bag measure without guessing packing density.
Log cooked leftovers in nutrition apps
Turn cups of prepared rice into grams for macro trackers that store mass while the user still thinks in cup scoops.
FAQ
How do I convert rice cups to grams?
By default from is cups, so the result is grams using the fixed density for that state.
What densities does the converter use?
Raw (uncooked) rice uses 185 grams per US cup. Cooked rice uses 158 grams per US cup. Both values are fixed conventional kitchen densities, not live database lookups.
Can I convert grams back to cups?
Yes. Set from to grams with the same amount and state fields.
Is the rice cups to grams converter free?
The browser tool runs free on your device.
Does it work for brown rice, sushi rice or wild rice?
It uses fixed weights for white rice, raw or cooked. Brown, sushi and wild rice can pack slightly differently in a real cup, so for those grains treat the result as an approximation.
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/rice \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"amount":1,"state":"raw"}'const res = await fetch("https://api.kit.forhosting.com/cook/rice", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"amount": 1,
"state": "raw"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/cook/rice",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"amount": 1,
"state": "raw"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/cook/rice", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"amount":1,"state":"raw"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"amount":1,"state":"raw"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/cook/rice", 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": 1,
"state": "raw"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "cook.rice",
"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 rice cups to grams needs raw versus cooked density
Case-insensitive names and friendly aliases such as uncooked, dry, prepared, and cooked rice 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
Optional field from defaults to cups so a rice-cups-to-grams search lands on the expected path; set from to grams when you are converting the other direction. Non-finite amounts, empty state strings, and missing required fields follow the same error path. Send a JSON body with the required number field amount set to a non-negative finite quantity, and the required string field state naming raw or cooked. Aliases value, quantity, and qty are accepted for the amount field; rice_state, form, and cooked_state are accepted for the state field when your client already uses those labels. Use result alone when a simple display is enough; use grams_per_cup when you want to show users why one cup of raw rice weighs more than one cup of cooked rice; use state_label when rendering multi-language shells that still need English kitchen names for the English landing. An unknown rice state such as basmati_only or a typo that does not match any alias fails with invalid_input and is not charged after validation rejects the request.
Practical kitchen workflows, limits, and API pricing
Use the prepaid API when a meal-planning app, macro tracker, recipe CMS, or localization pipeline must convert many rice lines under a stable KIT contract at $0.002 per successful item. Pair this endpoint with a general grams-to-cups ingredient table when the next line is flour or sugar rather than rice, or with a millilitres-to-cups converter when a liquid stock measure must share the same card.
Integration use cases
Normalize rice lines in recipe pipelines
Meal-planning APIs accept mixed cup and gram inputs with an explicit raw or cooked state and emit a stable dual-unit JSON contract.
Technical questions
What happens if the rice state is unknown?
The request fails with invalid_input. Only raw and cooked (plus documented aliases such as uncooked or prepared) are accepted; unknown rice states are rejected and not charged.