ForHosting KIT · Travel & geography

Quarter-mile time estimate

A 3,500-pound car with 300 horsepower should run the quarter mile in just over 13 seconds with a trap speed of about 103 mph. Use it to rank builds or sanity-check a claimed time before paying for track or dyno sessions. 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

Weight: 3,500
Horsepower: 300

You get

Weight unit: lb
Weight lb: 3,500
Et seconds: 13.2112788585
Trap speed mph: 103.173206364

Drag racers, car builders, and performance shoppers constantly ask how a given horsepower and curb weight might run on a standard quarter-mile strip. Full vehicle dynamics models need traction, gearing, aero, and elevation; for a first-cut planning number the industry still leans on compact empirical formulas that map weight-to-power into elapsed time and trap speed. This quarter-mile time estimate calculator accepts vehicle weight and horsepower, applies the classic Fox cube-root relations used across street and strip worksheets, and returns estimated ET in seconds plus trap speed in miles per hour and kilometres per hour, together with power-to-weight ratios. Weight can be entered in pounds or kilograms.

What the Fox quarter-mile formulas estimate and what they leave out

The quarter-mile, or four-oh-two point three three six metres, is the classic drag-strip distance for elapsed time and trap speed. Elapsed time (ET) is the clock from a clean launch to the finish beam; trap speed is the instantaneous speed measured near the end of the run, not the average speed over the whole distance. Empirically, both track strongly with the ratio of vehicle weight to horsepower for similar tire and launch conditions.

The Fox formulas encode that relationship with cube roots: ET equals five point eight two five times the cube root of weight in pounds divided by horsepower, and trap speed in miles per hour equals two hundred thirty-four times the cube root of horsepower over weight in pounds. Those constants were fitted to large sets of real strip data and remain the default in countless online quarter-mile calculators and notebook worksheets.

They are not a substitute for a dyno sheet, weather correction, or a full one-dimensional simulation that models clutch slip, shift times, and drag coefficient. They deliberately ignore traction limits, gearing, driver skill, altitude density, and rollout differences between tracks. Use them to rank builds, sanity-check claimed ET against published power, or fill a planning spreadsheet before you spend money on dyno time or test-and-tune sessions.

When you need weather-corrected index times or class rules, layer those corrections on top of this baseline rather than expecting the cube-root model to absorb them.

Who uses a quarter-mile estimate and why

Performance forums and build planners need a deterministic oracle so every client—mobile, web spreadsheet import, or shop kiosk—agrees on ET and trap for the same weight and horsepower. Auction and classifieds tools can flag unrealistic claimed times against stated power without standing up a full vehicle-dynamics stack. Education and motorsport media can embed the calculator next to explainers of power-to-weight without reinventing cube-root edge cases for zero weight or non-finite input.

Failed validation does not consume balance. Keep requests small, pin the rounded ET and trap values in tests, and you get reproducible quarter-mile estimates for comparison tables, LMS modules, and edge workers without hosting custom strip math infrastructure of your own.

What you can do with it

Build planning and power upgrades

Compare estimated ET and trap before and after a horsepower or weight change so you can prioritise intake, turbo, or weight-reduction work.

Claimed-time sanity checks

Flag listings or forum posts where a claimed quarter-mile time is far outside the Fox estimate for the stated weight and horsepower.

FAQ

Is this as accurate as a real drag-strip pass?

No. It is an empirical baseline that ignores traction, gearing, aero, weather, and driver skill. Use it for planning and ranking, not as a substitute for a timed pass.

What formula does the quarter-mile estimate use?

It uses the Fox formulas: elapsed time is 5.825 times the cube root of weight in pounds divided by horsepower, and trap speed in mph is 234 times the cube root of horsepower divided by weight.

Should the weight include the driver?

Yes. Enter the weight as raced, with the driver on board when you know it. You can type it in pounds or kilograms; kilograms are converted to pounds before the formulas are applied.

What is the difference between trap speed and average speed?

Trap speed is the instantaneous speed measured near the end of the run, while elapsed time runs from a clean launch to the finish beam. Neither one is the average speed over the whole quarter mile.

Which horsepower figure should I enter?

Use the figure you want to model, whether crank, flywheel or chassis horsepower. The estimate simply follows the number you give, so compare builds using the same kind of figure every time.

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/travel/quarter-mile-estimate

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/travel/quarter-mile-estimate \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"weight":3500,"horsepower":300}'

const res = await fetch("https://api.kit.forhosting.com/travel/quarter-mile-estimate", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "weight": 3500,
    "horsepower": 300
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/travel/quarter-mile-estimate",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "weight": 3500,
    "horsepower": 300
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/travel/quarter-mile-estimate", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"weight":3500,"horsepower":300}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"weight":3500,"horsepower":300}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/travel/quarter-mile-estimate", 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": 3500,
  "horsepower": 300
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "travel.quarter_mile_estimate",
  "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 values—missing fields, zero or negative weight or power—fail with a clear invalid_input error instead of inventing a run time.

Input contract, response shape, and error behaviour

Both weight and horsepower must be strictly greater than zero. Example: three thousand five hundred pounds and three hundred horsepower yields roughly a mid-thirteen-second ET and about one hundred three miles per hour trap—numbers that line up with many street muscle-car ballparks. POST a JSON body with two required finite numbers: weight, the as-raced vehicle mass including driver when you can supply it, and horsepower, the power figure you want to model—crank, flywheel, or chassis horsepower depending on how you keep your notes. Each field may arrive as a JSON number or as a numeric string; aliases such as vehicle_weight, mass, and w for weight, and hp, power, and bhp for horsepower are accepted. Optional weight_unit defaults to lb (pounds); set it to kg to convert kilograms into pounds with the exact international factor before applying the formulas. Missing fields, empty strings, NaN, Infinity, zero, and negative values fail with invalid_input messages that name the field. Those validation failures are not billed. On success the body echoes the input weight and unit, weight_lb after conversion, horsepower, et_seconds, trap_speed_mph, trap_speed_kmh, lb_per_hp, hp_per_1000_lb, the formula strings for ET and trap, method fox_quarter_mile, and a distance note confirming the one-quarter-mile standard. Pair the estimate with your own traction or altitude factors if your use case needs them; this endpoint implements only the Fox analytic baseline.

Integration use cases

Content widgets and comparison tables

Embed a free browser calculator or batch API calls that rank vehicles by estimated strip performance using a single deterministic formula.

Technical questions

How is quarter-mile ET estimated from weight and horsepower?

Using the Fox formula: ET (seconds) = 5.825 × (weight_lb / HP)^(1/3). Send positive weight and horsepower; the API returns et_seconds plus trap speed and power-to-weight ratios.

How is trap speed calculated?

Trap speed (mph) = 234 × (HP / weight_lb)^(1/3). The response also includes trap_speed_kmh using the exact mph-to-km/h factor.

What units does weight use?

Pounds (lb) by default. Set weight_unit to kg to enter kilograms; they are converted to pounds before the formulas run.

What does the quarter-mile time estimate 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