ForHosting KIT · Developer Utilities

Yeast amount from flour weight calculator by rise speed

This yeast amount from flour weight calculator turns a flour weight into a practical yeast weight using one of three fixed rise-speed presets.

● BetaFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Choose slow, standard, or fast, and the calculator applies a consistent baker percentage to the flour. The result is useful for scaling dough formulas without repeating percentage arithmetic. It is deliberately deterministic: the same flour weight and speed always return the same yeast amount, making it suitable for recipe notes, production worksheets, and automated bakery tools.

Choose a rise speed that matches your schedule

The rise-speed setting selects a fixed yeast percentage rather than attempting to predict fermentation time. Slow uses 0.3% yeast relative to flour, standard uses 0.7%, and fast uses 1.0%. Choose slow when the dough has a generous fermentation window and you want a restrained yeast quantity. Choose standard for a general-purpose dough schedule that sits between extended and accelerated fermentation. Choose fast when a larger yeast dose is appropriate for a shorter planned rise. These labels describe the calculation preset, not a guaranteed clock time. Actual dough speed also depends on yeast type, temperature, salt, sugar, hydration, flour strength, mixing, and dough size. Keeping the presets fixed is valuable because it makes recipe scaling repeatable: two people entering the same flour weight and rise speed receive exactly the same number. Treat the selected percentage as a clear starting point for your formula, then use your established process and observations to decide whether a future batch needs adjustment.

Understand the baker percentage calculation

Baker percentages express each ingredient as a percentage of total flour weight, with flour always treated as 100%. This calculator multiplies the entered flour grams by the percentage attached to the chosen rise speed, then divides by 100. For example, a standard setting applies 0.7 grams of yeast for every 100 grams of flour. The result is rounded to three decimal places, which preserves useful precision for small doughs while keeping the output stable for software and recipe records. Enter the combined weight of all flour in the dough, including different wheat flours or other milled grains that belong in the formula. Do not enter the total dough weight, because water, salt, oil, preferments, and other ingredients are not the basis of this calculation. Flour must be a finite number greater than zero. Zero and negative weights are rejected because they cannot describe a usable baker formula and would produce a meaningless yeast recommendation.

Use the result responsibly in a real dough process

Read the returned yeast weight in grams and weigh it with a scale suited to the quantity. A kitchen scale that resolves only whole grams may be inadequate for a small batch or the slow preset; a finer scale helps you reproduce fractional-gram amounts. The calculator intentionally does not convert between instant, active dry, and fresh yeast. Those forms have different conventions and may require a separate conversion before the number is used. It also does not compensate for a preferment, sourdough starter, cold refrigerator fermentation, enriched dough, unusually warm room, or a yeast manufacturer's specific guidance. In a production workflow, save the flour weight, selected rise speed, baker percentage, and returned yeast grams together so the formula remains auditable. When scaling a tested recipe, keep the rise-speed preset unchanged unless you intentionally want to alter the yeast percentage. The API price is $0.002 per calculation, while the pure calculation remains consistent across repeated calls and environments.

What you can do with it

Scale a bread formula

Recalculate yeast after increasing or decreasing total flour while preserving a selected rise-speed percentage.

Prepare bakery production sheets

Generate a repeatable yeast entry from each batch's flour weight for a documented slow, standard, or fast preset.

Check recipe arithmetic

Compare a written yeast quantity with the result of a transparent baker percentage calculation.

FAQ

What percentages do the rise-speed presets use?

Slow uses 0.3%, standard uses 0.7%, and fast uses 1.0% of the flour weight.

Does the calculator guarantee a specific rise time?

No. It applies a fixed percentage preset. Temperature, dough composition, yeast condition, and handling also affect fermentation time.

Which yeast type does the result represent?

The result is a formula weight only and does not convert between instant, active dry, or fresh yeast. Apply the convention used by your recipe or process.

Should flour in a preferment be included?

Use the total flour basis required by your formula. If your baker percentages include preferment flour in total flour, include it here as well.

Why are zero and negative flour weights rejected?

A baker percentage requires a positive flour basis. Zero or negative flour would not describe a meaningful dough formula.

What does an API calculation cost?

Each API calculation costs $0.002.

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

POSThttps://api.kit.forhosting.com/cook/yeast-amount-by-flour

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/yeast-amount-by-flour \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"flour_g":500,"rise_speed":"standard"}'

const res = await fetch("https://api.kit.forhosting.com/cook/yeast-amount-by-flour", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "flour_g": 500,
    "rise_speed": "standard"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/cook/yeast-amount-by-flour",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "flour_g": 500,
    "rise_speed": "standard"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/cook/yeast-amount-by-flour", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"flour_g":500,"rise_speed":"standard"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"flour_g":500,"rise_speed":"standard"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/cook/yeast-amount-by-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_g": 500,
  "rise_speed": "standard"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "cook.yeast_amount_by_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

Per request$0.002

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.

Read the full KIT documentation →