Self-rising flour calculator
For 120 grams of all-purpose flour, add 6 grams of baking powder (1.5 teaspoons) and 1.5 grams of salt (a quarter teaspoon). Enter your flour weight and get both amounts, so a self-rising recipe rises as written. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Flour weight
- 120
- Baking powder g
- 6
- Salt g
- 1.5
- Baking powder tsp
- 1.5
- Salt tsp
- 0.25
Self-rising flour is all-purpose wheat flour that already contains a chemical leavener and a measured pinch of salt, so biscuits, pancakes, muffins, and other quick breads rise without a separate baking-powder line on the recipe card. Most home pantries stock plain all-purpose flour, not a dedicated self-rising bag, and commercial blends still follow a small, fixed ratio of powder and salt to flour mass. This calculator takes that flour weight and returns both additive amounts you should whisk in before you mix wet ingredients. The conversion uses the conventional United States kitchen formula of one and one-half teaspoons of baking powder and one-quarter teaspoon of table salt per one hundred twenty grams of all-purpose flour, which is the same cup-scale recipe published by major flour mills. Grams of each additive are derived from standard teaspoon masses so a digital scale and a measuring-spoon set stay in agreement.
What homemade self-rising flour is and the ratio this tool uses
Self-rising flour is not a different wheat: it is all-purpose flour with baking powder and salt already blended through the bag so chemical leavening is even before you add milk, eggs, or fat. Biscuits, soda bread, pancakes, muffins, and many skillet cornbreads were written for that mix, which is why a recipe that says self-rising flour will taste flat or salty if you substitute plain flour and guess the extras.
The mill convention used here is the United States cup scale: one cup of all-purpose flour is one hundred twenty grams, and that cup takes one and one-half teaspoons of baking powder plus one-quarter teaspoon of table salt. A level teaspoon of baking powder is taken as four grams and a level teaspoon of table salt as six grams, so the same cup becomes six grams of powder and one and one-half grams of salt.
Those masses are five percent and one and one-quarter percent of the flour weight, which is why the calculator is a pair of multiplies rather than a lookup table. Whisk the powder and salt through the flour until the color is uniform; pockets of leavener leave tunnels or bitter spots in a biscuit.
This is not a cups-to-grams density converter and not a baker's-percentage expander for a full dough formula: it only answers how much baking powder and how much salt to add to a known all-purpose flour weight so the mix behaves like self-rising flour. Cake flour, bread flour, and whole-wheat flour have different protein and absorption; they are outside this contract. Do not add extra baking soda unless the recipe already calls for an acid such as buttermilk on top of the self-rising blend.
Where a self-rising mix calculator earns its keep
Home bakers who keep only all-purpose flour still cook from Southern biscuit, pancake, and muffin cards that list self-rising flour as a single ingredient; converting the weighed flour into powder and salt once, then whisking, is faster than buying a second bag that goes stale. Recipe apps and meal-kit backends often store a self-rising flag on a formula and expand it to explicit baking-powder and salt lines when rendering a shop list, so the shopper never has to keep a specialty flour in stock.
Test kitchens that publish both volume and weight versions of a biscuit recipe need a single source of truth for the extras rather than three editors converting cups by hand. Prefer this capability when you already know the all-purpose flour mass and need both additive amounts; it is not a hydration calculator, not a yeast converter, and not a flour cups-to-grams density tool.
What you can do with it
Turn pantry all-purpose flour into a biscuit mix
Weigh the flour you will use, add the returned baking powder and salt, whisk until even, and bake from any recipe that calls for self-rising flour.
Expand a self-rising flag in a recipe app
Store formulas with a self-rising toggle and, at render time, replace that flag with explicit baking-powder and salt gram lines from the flour weight.
Classroom check against mill ratios
Culinary students scale a 120 g cup to a 500 g lab batch and compare their calculated powder and salt against this deterministic result.
FAQ
How much baking powder and salt do I add to all-purpose flour?
Per 120 g (1 US cup) of all-purpose flour add 1.5 tsp (6 g) baking powder and 0.25 tsp (1.5 g) salt.
Why must flour weight be a positive number?
A zero or negative mass cannot be turned into a mix.
Does this work for cake flour or bread flour?
No. The mill ratio used here is the all-purpose cup scale (120 g per cup). Cake and bread flours differ in protein and are outside this contract.
Are the teaspoon amounts the same as the gram amounts?
Yes, they describe the same additives. Grams use 4 g per teaspoon of baking powder and 6 g per teaspoon of table salt so a scale and spoons agree.
Why do I need to whisk the baking powder and salt through the flour?
Because pockets of leavener leave tunnels or bitter spots in a biscuit. Whisk the powder and salt through the flour until the color looks uniform, and only then add the milk, eggs or fat.
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/self-rising-flour \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"flour_weight":120}'const res = await fetch("https://api.kit.forhosting.com/cook/self-rising-flour", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"flour_weight": 120
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/cook/self-rising-flour",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"flour_weight": 120
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/cook/self-rising-flour", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"flour_weight":120}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"flour_weight":120}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/cook/self-rising-flour", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"flour_weight": 120
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "cook.self_rising_flour",
"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
Enter a strictly positive flour mass; a zero, negative, or non-numeric weight fails with invalid_input and is not billed.
Input contract, response shape, and error behaviour
Numeric strings that parse as ordinary decimal or scientific notation are accepted so spreadsheet exports and form widgets do not need a second coerce. Failed validation is never billed. Optional output keys are omitted rather than set to null. POST a JSON body with one required finite number: flour_weight (aliases flour, flour_g, flour_mass, weight, grams, amount), the all-purpose flour mass in grams. The field must be strictly positive because a zero or negative bag cannot be turned into a mix; empty strings, non-finite values, and free text fail with invalid_input naming flour_weight. On success the body echoes the rounded flour_weight and returns baking_powder_g and salt_g as the two additive masses, baking_powder_tsp and salt_tsp as the matching spoon measures, formula as the closed cup-scale identity, and message as a one-line English summary you can print next to a scale. Worked check: flour_weight one hundred twenty yields six grams (one and one-half teaspoons) of baking powder and one and one-half grams (one-quarter teaspoon) of salt; two hundred forty grams doubles every additive. Pricing is a flat $0.002 per successful request with unit item. Values whose absolute magnitude exceeds one trillion are rejected so a pasted unit error cannot overflow the JSON number.
Where a self-rising mix calculator earns its keep
Culinary instructors demonstrate that the mill ratio is linear: changing flour from one hundred twenty grams to five hundred grams multiplies both additives by the same factor, and a deterministic API gives students an instant check against their own scale tickets. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when you deliberately send a zero weight to verify error handling.
Technical questions
What does the self-rising flour calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.