Butter sticks to grams converter
This butter sticks to grams converter turns a quantity written in US sticks into grams using one clear recipe rule: every stick equals exactly 113 grams.
Run — free
It is useful when an American recipe lists butter by the stick but your kitchen scale uses metric units. Enter a whole, fractional, or decimal number of sticks and receive a deterministic result immediately. The calculation is deliberately focused on this single conversion, so there are no ingredient choices, density assumptions, or hidden unit settings to interpret.
Convert the recipe quantity
Start with the number of US butter sticks printed in the recipe and enter it in the sticks field. Whole numbers work for recipes that call for one or two packages, while decimals handle quantities such as 0.5, 1.25, or 2.75 sticks. The converter multiplies that number by 113 and reports the corresponding mass in grams. For example, two sticks follow the same direct rule as any other value: the input quantity is multiplied once, without a density table or a regional package lookup. This makes the tool particularly helpful when a recipe assumes the familiar American stick markings but your butter is sold as a block. You can weigh the reported gram amount directly on a metric kitchen scale. Zero is accepted and produces zero grams, which can also be useful in spreadsheets or recipe software where an optional ingredient may have a calculated quantity of zero. Negative values, missing values, non-numeric text, and non-finite numbers are rejected instead of producing a misleading kitchen measurement.
Understand the fixed conversion rule
This capability defines one US stick as exactly 113 grams for every calculation. Its result is therefore predictable: the same sticks input always returns the same grams output, regardless of device, location, brand, or time. That fixed value is a practical recipe conversion and should be distinguished from converters that derive a stick from a quarter avoirdupois pound and display additional decimal places. Here, 113 is the complete factor, not a rounded display applied after another hidden factor. The algorithm accepts fractional sticks because recipe markings commonly divide a stick into halves, quarters, or tablespoons, but it does not attempt to convert tablespoons or cups as separate input units. If a recipe gives another unit, first determine the number of sticks or use a converter intended for that source unit. The output includes the normalized sticks value alongside grams, making it easy to confirm what was interpreted. Results are rounded only to stabilize ordinary floating-point arithmetic, with up to ten decimal places retained when a fractional input requires them.
Use the result reliably
For manual cooking, place a bowl on a scale, tare it, and add butter until the display reaches the returned gram value. If the scale shows only whole grams, use its normal rounding behavior and remember that the source conversion itself is based on 113 grams per stick. In an automated workflow, send an object containing the sticks field and read grams from the response. Each request processes one item and costs $0.002 through the API, while the browser experience can perform the same pure calculation locally. The function does not call a network service, read a clock, use random values, or preserve state between calculations, so retries are consistent. Validation is strict on purpose: a missing quantity, negative number, Infinity, NaN, arbitrary phrase, array, or unrelated object returns an invalid-input error. This lets recipe importers and meal-planning systems stop on malformed data rather than silently treating it as zero. The accepted maximum is one trillion sticks, far above culinary needs but bounded so accidental extreme inputs remain controlled and serializable.
What you can do with it
Follow an American recipe with a metric scale
Turn a recipe quantity stated in US butter sticks into the gram target you can weigh in a bowl.
Normalize imported recipe data
Convert stick-based butter quantities to a consistent gram field before storing or displaying a recipe.
Scale a batch deterministically
Pass a fractional or multiplied stick quantity and receive the same fixed-factor result on every run.
FAQ
How many grams are in one stick of butter?
This converter uses exactly 113 grams for one US stick of butter.
Can I convert half or quarter sticks?
Yes. Enter a decimal such as 0.5 or 0.25, and the converter multiplies it by 113.
Why might another converter show 113.4 grams?
Some tools derive the value from one quarter of an avoirdupois pound. This capability intentionally uses the specified fixed recipe mass of exactly 113 grams per stick.
What inputs cause an error?
Missing, negative, non-numeric, non-finite, and excessively large stick quantities return an invalid-input error.
What does the API conversion cost?
Each request costs $0.002. The calculation is also available in the browser experience.
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/butter-sticks-to-grams \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"sticks":2}'const res = await fetch("https://api.kit.forhosting.com/cook/butter-sticks-to-grams", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"sticks": 2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/cook/butter-sticks-to-grams",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"sticks": 2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/cook/butter-sticks-to-grams", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"sticks":2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"sticks":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/cook/butter-sticks-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
{
"sticks": 2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "cook.butter_sticks_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. |