ForHosting KIT · Home, food & hobbies

Baker's percentage to weight calculator

With 1,000 grams of flour, a 65% water line on a formula card means 650 grams of water. Enter your flour weight and any baker's percentage to weigh water, salt, yeast or fat straight onto the scale. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Flour weight: 1,000
Bakers pct: 65

You get

Ingredient weight: 650

Baker's percentage is the language of professional dough formulas: every ingredient is written as a percent of total flour weight, so flour always sits at one hundred percent and water, salt, yeast, fat, and preferments scale cleanly when batch size changes. A baker's percentage to weight calculator reverses that notation—given how much flour you will use and the percentage printed on a formula card, it returns the absolute ingredient weight you should scale out. Home bakers following a 65 percent hydration formula on a digital scale, production bakers scaling a preferment to a new flour load, and recipe-app developers who store formulas as percentages all need the same deterministic multiply without spreadsheet drift. Enter total flour weight and baker's percentage; the tool returns ingredient weight, the closed-form formula string, and a short message you can show next to a scale readout.

What baker's percentage means and why flour is always 100%

In the baker's percentage system, the sum of all flour in a formula is defined as one hundred percent of the formula base. Every other ingredient—water, salt, instant yeast, butter, sugar, eggs, prefermented flour, or add-ins—is expressed as a percentage of that flour total, not of the finished dough mass. A classic lean bread might list water at sixty-five percent, salt at two percent, and yeast at one percent; those numbers stay fixed while you change how many kilograms of flour you mix.

Because the percentages are relative to flour alone, dough hydration is simply the water percentage, and enrichment levels remain comparable across recipes written in different kitchen units. Converting a baker's percentage back to weight is therefore a single product: ingredient weight equals flour weight times baker's percentage divided by one hundred. If you hold one thousand grams of flour and the formula says sixty-five percent water, you need six hundred fifty grams of water; at two percent salt you need twenty grams of salt.

Values above one hundred percent are valid when the formula reports dough yield (flour plus all other ingredients as a percent of flour) or when a large preferment is listed against total flour. Values of zero are allowed for optional ingredients you are omitting. Negative percentages have no physical meaning in this system and are rejected.

This calculator does not invent flour types, densities, or cup measures—it only reverses the percentage arithmetic so your scale matches the formula card.

What you can do with it

Scale a formula card onto a digital scale

Pick a flour load in grams, convert each baker's percentage line (water, salt, yeast, fat) into ingredient weights, and weigh without mental arithmetic drift.

Production mix tickets from flour targets

Bakeries expand daily flour allotments into full ingredient lists from fixed baker's percentages for consistent hydration and salt across batch sizes.

FAQ

How do I convert baker's percentage to ingredient weight?

Multiply total flour weight by baker's percentage divided by 100. Example: 1000 g flour at 65% water → 650 g water.

Why must flour weight be positive?

In baker's percentage, flour is the 100% baseline.

Can baker's percentage be greater than 100?

Yes. Preferments and dough-yield lines often exceed 100% of flour. Only negative percentages are rejected.

What does 65% hydration mean in grams?

Hydration is simply the water percentage, so the water weighs 65% of the flour. With 1,000 grams of flour you weigh 650 grams of water, whatever the size of the batch.

Is the percentage taken from the flour or from the whole dough?

From the total flour only, never from the finished dough. That is why flour always counts as 100% and every other line, from salt to butter, scales with it when you change the batch.

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

POSThttps://api.kit.forhosting.com/cook/bakers-pct-to-weight

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/bakers-pct-to-weight \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"flour_weight":1000,"bakers_pct":65}'

const res = await fetch("https://api.kit.forhosting.com/cook/bakers-pct-to-weight", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "flour_weight": 1000,
    "bakers_pct": 65
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/cook/bakers-pct-to-weight",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "flour_weight": 1000,
    "bakers_pct": 65
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/cook/bakers-pct-to-weight", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"flour_weight":1000,"bakers_pct":65}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"flour_weight":1000,"bakers_pct":65}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/cook/bakers-pct-to-weight", 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": 1000,
  "bakers_pct": 65
}

Example response

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

Technical notes

Invalid flour weight or a negative percentage fails with invalid_input instead of inventing a mass.

Input contract, response shape, and error behaviour

Flour weight must be strictly positive because flour is the one-hundred-percent baseline; zero or negative flour would make the percentage system undefined. Baker's percentage must be non-negative; zero returns zero ingredient weight, which is correct for an omitted optional item. Rounding uses twelve decimal places so goldens stay byte-stable across runtimes without changing kitchen-scale precision. Failed validation is never billed. POST a JSON body with two required finite numbers: flour_weight (aliases flour, flour_g, flour_mass, total_flour, flour_wt)—the total flour mass in whatever unit you will use for the ingredient, typically grams—and bakers_pct (aliases percent, pct, baker_percent, bakers_percent, percentage, bp)—the baker's percentage of that ingredient relative to flour. Both fields accept JSON numbers or strict numeric strings; empty strings, non-finite values, and free text fail with invalid_input naming the field. On success the body echoes rounded flour_weight and bakers_pct, returns ingredient_weight as flour_weight times bakers_pct over one hundred, formula as the closed-form identity, and message as a one-line English summary suitable for UI copy. Example: flour_weight one thousand and bakers_pct sixty-five yields ingredient_weight six hundred fifty. Pricing is a flat $0.002 per successful request with unit item.

Where baker percentage conversion earns its keep

Home bakers scaling a published sourdough or pizza formula onto a kitchen scale convert each line from percent to grams once the flour load is chosen, avoiding mental multiply errors that throw hydration off by tens of grams. Bakery production sheets start from a flour target for the day and expand every ingredient—salt, malt, oil, preferment—from baker's percentages so mixers receive exact scale tickets. Prefer this capability when you already know total flour and one ingredient's baker percent; it is not a full multi-line formula balancer, not a cups-to-grams flour density tool, and not a hydration-from-finished-dough reverse engineer. Culinary instructors teach the percent system by showing that changing flour from five hundred to eight hundred grams multiplies every other weight by the same factor while percentages stay fixed; a deterministic API gives students instant checks. Recipe apps and meal-kit backends often store dough formulas as percentage maps for unit-agnostic scaling, then call a tiny convert endpoint when rendering a shop list or scale UI. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when you deliberately send zero flour to verify error handling.

Integration use cases

Deterministic tests for recipe apps

Developers store formulas as percent maps and generate golden flour-weight × percent pairs plus invalid flour and negative-percent rejections for CI.

Technical questions

Which units does the calculator use?

Any consistent weight unit. If flour_weight is in grams, ingredient_weight is in grams; the formula is unit-agnostic as long as both sides match.

What does the baker's percentage to weight calculator cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free