Teaspoons to grams converter by ingredient
A teaspoon measures volume, while a gram measures weight, so there is no single multiplier that works for every ingredient.
Run — free
This teaspoons-to-grams converter selects a practical kitchen density factor for the ingredient you name, then calculates the corresponding weight. Enter a non-negative number of US teaspoons and choose a supported ingredient to receive the grams, the normalized ingredient name, and the factor used. The calculation is deterministic, transparent, and suitable for recipe scaling, meal preparation, and consistent food-data entry.
Why the ingredient changes the answer
A teaspoon of water and a teaspoon of cocoa powder occupy the same nominal volume, but they do not contain the same amount of matter. Fine particles may trap air, crystals may settle closely, and liquids have their own characteristic densities. That is why a generic volume-to-weight conversion can produce a plausible-looking but incorrect recipe. This converter associates each supported ingredient with a practical grams-per-teaspoon factor and exposes that factor in the result. You can therefore see both the answer and the assumption behind it. The tool uses a US teaspoon of 5 milliliters, which is the common convention in modern recipe measurements. It treats ingredient factors as kitchen averages rather than laboratory constants. Brand, moisture, temperature, grinding, sifting, and how firmly a spoon is filled can all change a real measurement. For everyday cooking, the conversion provides a consistent baseline. For regulated nutrition work, commercial formulation, or experiments requiring traceable precision, weigh the actual material with a calibrated scale and follow the relevant measurement protocol.
How to enter a reliable conversion
Start with the volume exactly as it appears in the recipe, including fractional values such as 0.5 or 2.25 teaspoons. Choose the ingredient that most closely matches the named material; for example, use granulated sugar for ordinary white sugar and table salt for fine household salt. The converter normalizes capitalization and extra spaces, and it recognizes a few familiar aliases, but it deliberately rejects unknown ingredients. That behavior prevents a dangerous shortcut in which an unsupported powder is treated like water. The volume must be a finite, non-negative number. Zero is valid and returns zero grams, which is useful when calculations are generated from optional recipe components. Negative measures are rejected because they do not represent a physical ingredient volume. The result is rounded to three decimal places and includes the canonical ingredient name, the submitted teaspoon amount, the factor in grams per teaspoon, and the final weight. Keeping those fields together makes the calculation easy to audit, reproduce, or store with transformed recipe data.
Using the result in recipes and software
For a one-off kitchen task, enter the teaspoons and ingredient, then copy the gram result into your recipe notes. When scaling a recipe, convert the original spoon measurement before multiplying portions so that later calculations use one consistent unit. Developers can call the same deterministic calculation through the API for $0.002 per request, making it useful in recipe importers, nutrition-data preparation, shopping-list tools, and culinary publishing workflows. Store the returned factor alongside the grams if future readers need to understand how the weight was derived. Remember that spoon technique still matters: a packed spoon of brown sugar, a level spoon of flour, and a heaped spoon of cocoa are not interchangeable physical procedures. This calculator assumes representative kitchen measurements, not a particular cook's packing pressure. If a source recipe specifies packed, sifted, melted, coarse, or another preparation state, prefer a weight supplied by that source or verify the ingredient on a scale. The converter is best used to create consistent estimates when only teaspoon volume is available.
What you can do with it
Scale a baking recipe
Turn small spoon measurements into grams before multiplying a recipe for a larger or smaller batch.
Normalize imported recipes
Convert supported teaspoon entries into consistent weight fields while retaining the density factor used.
Prepare repeatable portions
Replace approximate spoon measures with practical gram targets for more consistent meal preparation.
FAQ
Can every ingredient use the same teaspoons-to-grams multiplier?
No. Teaspoons measure volume and grams measure weight, so the multiplier depends on the ingredient's density.
Which kind of teaspoon does this converter use?
It uses a US kitchen teaspoon defined as 5 milliliters.
Are the results exact enough for laboratory or commercial formulation work?
No. The factors are practical kitchen averages. Use calibrated weighing and a controlled protocol when traceable precision is required.
What happens if my ingredient is not supported?
The request returns an invalid input error instead of guessing a density or treating the ingredient like water.
Can I enter fractional teaspoons?
Yes. Any finite non-negative number is accepted, including decimal values such as 0.25 or 1.5.
What does an API conversion cost?
Each API request costs $0.002. The browser version can run locally without sending the calculation to a server.
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/conv/tsp-to-grams \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"teaspoons":2.5,"ingredient":"all-purpose flour"}'const res = await fetch("https://api.kit.forhosting.com/conv/tsp-to-grams", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"teaspoons": 2.5,
"ingredient": "all-purpose flour"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/tsp-to-grams",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"teaspoons": 2.5,
"ingredient": "all-purpose flour"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/tsp-to-grams", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"teaspoons":2.5,"ingredient":"all-purpose flour"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"teaspoons":2.5,"ingredient":"all-purpose flour"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/tsp-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
{
"teaspoons": 2.5,
"ingredient": "all-purpose flour"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.tsp_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. |