Foot-pounds of energy calculator
Muzzle energy in foot-pounds is the weight in grains times the speed in feet per second squared, divided by 450240, the formula printed beside factory load tables. Enter grains and fps, such as 150 grains at 2700 fps, to get the energy. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Weight
- 150
- Velocity
- 2,700
- Energy
- 2,428.7046908316 ft-lbf
- Equation
- E = (150 × 2700²) / 450240 = 2428.704690831557
This foot-pounds of energy calculator reports the kinetic energy of a projectile in foot-pounds force from its weight in grains and its velocity in feet per second. American hunters, reloaders, and ballistics students use the industry formula E equals weight times velocity squared divided by 450240 — the same identity printed beside factory load tables and chronograph apps. Enter a non-negative grain weight and a non-negative fps reading; the result is translational energy in ft-lbf, the customary unit on US ammunition boxes. Zero weight or zero speed yields zero energy.
What foot-pounds of energy means and where 450240 comes from
Foot-pounds of energy is the customary US unit for the translational kinetic energy of a bullet, slug, or other projectile. Ballistics tables, reloading manuals, and factory cartridge boxes almost always quote muzzle energy in foot-pounds rather than joules, and they almost always start from two numbers the shooter already has: projectile weight in grains and a chronograph or advertised velocity in feet per second. The closed-form identity that turns those two readings into energy is E equals weight times velocity squared, divided by 450240.
That divisor is not a marketing fudge: seven thousand grains make one avoirdupois pound, and 32.16 feet per second squared is the conventional gravitational acceleration used in US small-arms arithmetic, so two times 7000 times 32.16 equals 450240. Because velocity is squared, a modest gain in fps usually moves the energy figure more than a similar relative gain in grain weight. Doubling speed at a fixed weight quadruples energy; doubling weight at a fixed speed only doubles energy.
This calculator does one job: it takes grains and fps, divides according to that industry formula, and returns energy in ft-lbf. It does not estimate stopping power, wound cavity, sectional density, or drop. Treat the output as the textbook muzzle-energy number that sits beside a load, which is the figure hunters compare when they ask how many foot-pounds a cartridge delivers.
Identical inputs always produce identical floating-point results because the implementation is pure arithmetic with no network, randomness, or wall-clock dependence.
Where a foot-pounds figure belongs — and where it does not
Reloaders and hunters use foot-pounds of energy to compare two factory loads or two handloads when the box already prints a grain weight and a claimed velocity, or when a chronograph at the bench has just given a mean speed in fps. Physics and hunting-education courses use the same identity as a first numerical check: given 150 grains at 2700 feet per second, how many foot-pounds does the projectile carry, and does doubling the speed really quadruple the energy.
Prefer it when you already have grains and fps, which is the pair US shooters actually type. Keep requests inside the documented limits, pin the rounded energy in tests, and remember that drag, yaw, and a non-rigid target can move the energy that actually arrives far from the muzzle figure. Pair the calculator with other free deterministic physics helpers when you are assembling a small lab of screening tools rather than a full exterior-ballistics suite.
What you can do with it
Compare factory loads at the bench
Turn a box-stated grain weight and a chronograph velocity in fps into muzzle energy in foot-pounds so two cartridges can be compared on the same customary US scale.
Reloading and hunting-education checks
Check student or handload work that asks for kinetic energy in ft-lbf given projectile weight in grains and speed in feet per second.
FAQ
What formula does the foot-pounds of energy calculator use?
It uses the conventional US ballistics identity E = (weight × velocity²) / 450240, where weight is in grains and velocity is in feet per second. The energy is returned in foot-pounds (ft-lbf).
Why divide by 450240?
Seven thousand grains make one avoirdupois pound and 32.16 ft/s² is the conventional g used in US small-arms arithmetic. Two times 7000 times 32.16 equals 450240, which converts grain-and-fps kinetic energy into foot-pounds.
Why are negative weight and negative velocity rejected?
A negative projectile weight is not physical, and this calculator treats velocity as a non-negative ballistic speed. Zero is allowed and yields zero foot-pounds.
Does foot-pounds of energy equal stopping power?
Use it as the textbook muzzle-energy number, not as a terminal-performance index.
Why does bullet speed matter more than bullet weight?
Because velocity is squared in the formula. Doubling the speed at a fixed weight quadruples the energy, while doubling the weight at a fixed speed only doubles it.
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/phys/foot-pounds-of-energy \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"weight":150,"velocity":2700}'const res = await fetch("https://api.kit.forhosting.com/phys/foot-pounds-of-energy", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"weight": 150,
"velocity": 2700
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/phys/foot-pounds-of-energy",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"weight": 150,
"velocity": 2700
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/phys/foot-pounds-of-energy", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"weight":150,"velocity":2700}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"weight":150,"velocity":2700}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/phys/foot-pounds-of-energy", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"weight": 150,
"velocity": 2700
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "phys.foot_pounds_of_energy",
"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.
Limits
max_abs | 1000000000000 |
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
Negative weight or negative velocity is rejected with invalid_input and is not billed.
How to enter grain weight and fps velocity
Both values must be non-negative: a negative projectile weight is not physical, and a negative muzzle speed is not a ballistic speed for this calculator. Zero is allowed and yields zero foot-pounds, which is the classical result for a projectile at rest or of vanishing mass. If your source lists bullet mass in grams or kilograms, convert to grains first; if it lists velocity in metres per second, convert to feet per second first. This landing is the grains-and-fps path, not an SI kinetic-energy solver. POST a JSON body with two required finite numbers: weight in grains and velocity in feet per second. Aliases weight_grains, grains, bullet_weight, mass, and w are accepted for weight; velocity_fps, fps, speed, and v for velocity, so spreadsheets and typed forms can reuse the same contract. Each field may arrive as a JSON number or as a strict decimal string, including scientific notation; hex prefixes, embedded spaces, and empty strings fail with invalid_input naming the field. Absolute values must stay inside the published ceiling so the quotient remains finite in IEEE double precision on the Worker and in the browser. On success the response echoes rounded weight and velocity, reports energy in ft-lbf, and includes the formula E equals weight times velocity squared over 450240, a filled equation string, the unit ft-lbf, and the method tag foot_pounds_of_energy. Failed validation is never charged; a successful request costs $0.002.
Where a foot-pounds figure belongs — and where it does not
On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, invalid_input is not billed, and nothing is stored after the response returns.
Integration use cases
Cartridge tables and CI fixtures
Generate deterministic foot-pound columns for ammunition pages or automated tests without re-implementing E = (W × V²) / 450240 in every service.
Technical questions
What does the foot-pounds of energy calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.