Egg weight by size lookup
A large egg gives 50 g once the shell is off. Pick a USDA carton size, from peewee to jumbo, and get the average shelled weight in grams and ounces, together with the in-shell minimum set by its grade. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Size
- Large
- Size label
- Large
- Weight g
- 50
- Weight oz
- 1.7636980975
- In shell oz per dozen
- 24
Carton grades such as Small, Medium, Large, Extra Large, and Jumbo describe a legal weight class, not a diameter you can guess from a photograph. After the shell is discarded, the edible portion is what hydrates batter, sets custard, and fills the per-egg calorie line on a nutrition panel. This egg weight by size lookup accepts a USDA grading size — Peewee, Small, Medium, Large, Extra Large, or Jumbo — and returns the published average shelled weight in grams and avoirdupois ounces from a fixed table, together with the in-shell minimum implied by the ounces-per-dozen class.
What USDA egg grades mean and why shelled weight is not in-shell weight
United States Department of Agriculture egg grades such as Small, Medium, Large, Extra Large, and Jumbo are defined by a minimum net weight per dozen in the shell, not by a measured width or a hen breed. A Large dozen must weigh at least twenty-four ounces; Extra Large twenty-seven; Jumbo thirty; Medium twenty-one; Small eighteen; Peewee fifteen. Divide those class ounces by twelve and convert with the international avoirdupois ounce of 28.349523125 grams and you obtain the in-shell minimum for a single egg.
That minimum is not the number bakers scale recipes against. Nutrition tables and culinary conversion charts publish an average edible mass after the shell is removed: thirty-eight grams for Small, forty-four for Medium, fifty for Large, fifty-six for Extra Large, sixty-three for Jumbo, and thirty-two for Peewee. The shell is typically about ten to twelve percent of the in-shell mass, so the edible figure sits a few grams below the class minimum.
What you enter and what you get back
The form renders those values as a select. Numbers are rounded to twelve decimal places so goldens stay byte-stable across runtimes. Example: size large yields fifty grams shelled and an in-shell class of twenty-four ounces per dozen.
Example: size jumbo yields sixty-three grams shelled. Pin those deterministic products in tests so recipe cards and browser widgets stay aligned across releases.
Where an egg weight by size lookup earns its keep
Recipe sites and baking blogs need a single source of truth when a method says three large eggs and a reader only has mediums in the fridge, so the page can show fifty grams versus forty-four grams instead of a guessed tablespoon conversion. Nutrition and meal-prep apps that store a carton grade can attach a stable edible gram figure to each egg without scraping a supermarket page. Catering and bakery planning sheets convert a purchase of extra-large or jumbo cartons into batter mass before the first mix.
Culinary-school worksheets and food-label generators can echo the USDA class ounces beside the shelled grams so students see both the legal carton rule and the bowl weight. Failed validation does not consume balance. Document that results are published averages rather than a scale reading of the egg in your hand, keep USDA grade names in product copy, and you get reproducible kitchen math for bakers, CMS blocks, and edge workers without hosting your own conversion spreadsheet.
What you can do with it
Recipe sites and baking blogs
Turn a carton grade into a stable shelled-gram figure so a method that calls for large eggs can show the equivalent mass when readers only have medium or extra-large cartons.
Nutrition and meal-prep apps
Store the USDA size on a logged breakfast and attach the published edible grams and ounces without scraping a retailer page for each serving.
FAQ
Which egg sizes are supported?
Peewee, Small, Medium, Large, Extra Large, and Jumbo. Those are the USDA carton classes. European S/M/L/XL bands use different in-shell ranges and are not accepted.
What happens if I send an unknown size?
Unknown grades are not billed and never invent a mass.
Why is the shelled weight lower than the carton grade?
Because the grade sets a minimum weight per dozen in the shell, and the shell is typically ten to twelve percent of that mass. A dozen large eggs must weigh at least 24 ounces, yet each egg gives 50 g to the bowl.
Does it work with European S, M, L and XL eggs?
No. European bands use different in-shell ranges, and treating them as USDA labels would quietly mis-scale a recipe. The table covers only the USDA grades peewee, small, medium, large, extra large and jumbo.
Can it give the yolk and white weights separately?
No. It returns the average edible weight of the whole egg after the shell is removed. It does not estimate a yolk-only or white-only split, and it does not weigh an egg from a photo.
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/egg-weight \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"size":"large"}'const res = await fetch("https://api.kit.forhosting.com/cook/egg-weight", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"size": "large"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/cook/egg-weight",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"size": "large"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/cook/egg-weight", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"size":"large"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"size":"large"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/cook/egg-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
{
"size": "large"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "cook.egg_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
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
Unknown sizes fail with invalid_input instead of inventing a mass.
What USDA egg grades mean and why shelled weight is not in-shell weight
This endpoint stores those published shelled averages as a frozen table and computes the in-shell minimum from the ounces-per-dozen class, so clients can show both the legal grade definition and the mass that actually goes into the bowl. It does not weigh a photograph, estimate yolk-only or white-only splits, or convert European S, M, L, and XL bands, which use different in-shell ranges and would silently mis-scale a recipe if they were treated as USDA labels.
Input contract, response shape, and error behaviour
POST a JSON body with one required string field, size, set to a USDA grading size. Canonical values are peewee, small, medium, large, extra_large, and jumbo. Missing, empty, numeric, and unrecognized tokens fail with invalid_input naming the field and listing the supported sizes; those failures are not billed. On success the body echoes the canonical size and a display size_label, reports weight_g as the published average shelled mass, weight_oz as that mass divided by 28.349523125, in_shell_oz_per_dozen as the USDA class ounces, and in_shell_min_g as ounces per dozen divided by twelve times the ounce-to-gram factor. table names the source, formula restates the lookup and the in-shell conversion, and message is a one-line summary for UI copy.
Integration use cases
Bakery and catering purchase sheets
Convert a case of jumbo or extra-large eggs into expected batter mass from the same table the public widget uses.
Technical questions
How does the egg weight by size lookup work?
Send a USDA grading size (peewee, small, medium, large, extra_large, or jumbo). The API returns the published average shelled weight in grams and ounces, plus the in-shell class minimum from ounces per dozen.
Is the weight in-shell or shelled?
weight_g and weight_oz are the average edible (shelled) mass. in_shell_oz_per_dozen and in_shell_min_g describe the USDA in-shell class minimum, which is a few grams heavier because it still includes the shell.
What does the egg weight by size lookup cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.