Grains to teaspoons converter
Sixty grains of an ingredient that packs 15 to the teaspoon make 4 teaspoons, which is 20 ml. You supply the grains-per-teaspoon count for your own spoon and ingredient, and the tool divides, adding tablespoons and milliliters. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Grains
- 60
- Grains per teaspoon
- 15
- Result
- 4 tsp
- Teaspoons
- 4
- Tsp
- 4
- Tablespoons
- 1.3333333333
A grains-to-teaspoons converter turns a counted grain quantity of an ingredient into kitchen or compounding volume using a grains-per-teaspoon factor you supply. Pharmacists compounding powders, bakers scaling spice blends, home cooks reading a bag label, and seed-packaging desks all meet the same problem: a formula is stated in grains, but the scoop, dosing cup, or recipe line expects teaspoons. This tool divides the grain amount by the grains-per-teaspoon factor and returns the volume in teaspoons, echoing both inputs, a formula string, and ordered substitution steps you can paste into a batch sheet. The factor is never guessed: rice, kosher salt, poppy seed, and pharmaceutical granules pack differently, so the caller must provide how many grains occupy one teaspoon for that ingredient.
Why grains-to-teaspoons needs a packing factor, not a universal constant
The conversion is a single division: teaspoons equal grains divided by grains per teaspoon. That identity is exact for a given packing of a given ingredient, and it is the reason this landing exists separately from a grain-weight converter that only maps the avoirdupois grain to grams, milligrams, or ounces. A grain here is a countable unit of the ingredient—rice kernels, salt crystals, poppy seeds, or pharmaceutical granules—not the mass unit printed on a reloading scale.
Because bulk density, crystal size, moisture, and how tightly the scoop is filled all change how many grains occupy one teaspoon, the solver does not hard-code a universal factor from a kitchen table. Zero grains convert to zero teaspoons at any positive factor, which is the empty-scoop identity. Negative grain amounts are rejected because a physical ingredient quantity cannot be negative.
A factor that is zero would divide by zero; a negative factor would invent a negative volume from a positive count, which is not a scoop. Typical kitchen factors are large: kosher salt may pack tens of grains per teaspoon, long-grain rice hundreds, and poppy seed thousands; pharmaceutical granules can be far smaller. Always measure the factor on your own spoon and ingredient rather than copying a generic chart, because a heaped teaspoon and a level teaspoon of the same spice are not the same packing.
Practical checks, related searches, and when to use another tool
Prefer sending bare numbers when you control the client; string numbers are accepted only when they match a strict finite numeric pattern without units, thousand separators, or currency symbols. Round-trip sanity checks are easy: convert sixty grains at fifteen grains per teaspoon and confirm four teaspoons, convert one hundred grains at thirty-two grains per teaspoon and confirm three point one two five teaspoons, or convert zero grains at any positive factor and confirm zero teaspoons.
When teaching, show that multiplying the published teaspoons by the factor recovers the original grains within the same twelve-decimal rounding used for published fields, which makes the identity visible instead of hiding it behind a mysterious coefficient. Stay inside the absolute range so the divide cannot overflow into a non-finite result the solver must reject, and never send a signed negative factor hoping the tool will treat it as a direction.
This landing targets people searching for grains to teaspoons, gr to tsp converter, or a calculator that divides by a grains-per-teaspoon factor; it is not a grain-mass hub, not a millilitres-to-teaspoons primary form, and not a cups or fluid-ounce kitchen converter. Prefer this capability when the input is already a grain count of an ingredient and you already know how many grains fill one teaspoon; if you only need to convert the avoirdupois grain as a mass unit to grams, use the grain-weight converter instead.
What you can do with it
Pharmacy compounding scoops
Turn a grain-dosed powder into teaspoon volume using the packing factor measured on your own compounding spoon, then record teaspoons, tablespoons, and millilitres on the batch sheet.
Spice and seed recipe scaling
Convert a counted grain amount of rice, poppy seed, or kosher salt into teaspoons for a recipe line when the bag or mill lists grains instead of volume.
FAQ
How do I convert grains of an ingredient to teaspoons?
Send a nonnegative grain amount and a strictly positive grains-per-teaspoon factor.
Why do I have to supply the grains-per-teaspoon factor?
Packing is ingredient-specific. Rice, salt, poppy seed, and pharmaceutical granules fill a teaspoon differently, so a universal constant would be wrong. Measure grains in your own level teaspoon and pass that factor.
What happens if the grains-per-teaspoon factor is zero or negative?
Division by zero is undefined, and a negative packing factor does not describe a physical scoop, so those cases are not billed.
Can I convert a zero grain amount?
Yes. Zero grains at any positive factor converts to zero teaspoons. A negative grain amount is rejected because an ingredient quantity cannot be negative.
Is a grain here the same as the weight unit grain?
No. Here a grain is one countable piece of the ingredient, such as a rice kernel, a salt crystal or a poppy seed. The grain used as a weight on reloading scales is a different unit with its own converter.
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/conv/gr-to-tsp-converter \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"grains":60,"grains_per_teaspoon":15}'const res = await fetch("https://api.kit.forhosting.com/conv/gr-to-tsp-converter", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"grains": 60,
"grains_per_teaspoon": 15
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/gr-to-tsp-converter",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"grains": 60,
"grains_per_teaspoon": 15
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/gr-to-tsp-converter", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"grains":60,"grains_per_teaspoon":15}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"grains":60,"grains_per_teaspoon":15}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/gr-to-tsp-converter", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"grains": 60,
"grains_per_teaspoon": 15
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.gr_to_tsp_converter",
"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
Zero or negative factors fail with invalid_input because division by zero is undefined and a negative packing density does not describe a physical scoop.
Why grains-to-teaspoons needs a packing factor, not a universal constant
Those two factor cases fail as invalid_input rather than returning Infinity or a signed volume.
Input contract, response shape, and error behaviour
Absolute values must stay within the published limit of one trillion. Send a JSON body with two required finite numbers: grains, the nonnegative count or grain amount of the ingredient, and grains_per_teaspoon, the strictly positive packing factor for one teaspoon of that ingredient. Aliases grain, amount, value, quantity, and mass_grains are accepted for the first field; factor, gpt, grains_per_tsp, and tsp_factor are accepted for the second so SDK clients and form posts can use the name that fits the product. On success the response echoes rounded grains and grains_per_teaspoon, sets teaspoons, tsp, and result to the same rounded teaspoon magnitude, tablespoons to teaspoons divided by three, milliliters to teaspoons times five using the metric teaspoon identity, unit to the token tsp, formula to the string teaspoons equals grains divided by grains_per_teaspoon, message to a short English summary, and steps to an ordered array of substitution lines. Failed validation—missing fields, non-finite numbers, a negative grain amount, a zero or negative factor, values outside absolute limits, or a non-finite converted result—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item.
Practical checks, related searches, and when to use another tool
Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately pass a zero factor or omit grains_per_teaspoon.
Integration use cases
Packaging and QA worksheets
Pin a deterministic grains-per-teaspoon factor in tests so filling-line worksheets and CI fixtures agree on teaspoon volume for a known grain count.
Technical questions
What does this grains to teaspoons converter cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.