ForHosting KIT · Engineering & construction

Tire size calculator

A 205/55R16 tire has a 112.8 mm sidewall, a 631.9 mm overall diameter and turns 503.73 times per kilometre: type any metric tire code to get the same four figures and compare sizes before you change wheels. 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

Tire code: 205/55R16

You get

Section width (mm): 205
Aspect ratio (%): 55
Rim diameter (in): 16
Sidewall height (mm): 112.8

Parses a metric tire code like 205/55R16 and returns sidewall height, overall diameter, circumference in millimetres and revolutions per kilometre, all derived from the width, aspect ratio and rim size.

What the three numbers in a tire code mean

A metric code such as 205/55R16 packs three measurements. The first is the width of the tire in millimetres, 205 here. The second, 55, is not a length at all: it is the sidewall height as a percentage of that width, so the sidewall is 205 times 55 divided by 100, or 112.75 mm. The last number is the rim diameter in inches, 16 in this case. Anything written after the rim size, such as the load and speed rating, is ignored, because it does not change the geometry. From those three values the calculator works out every other figure, and it shows the width, ratio and rim it read so you can check them.

From diameter to revolutions, and the usual slip-ups

The overall diameter is the rim converted to millimetres plus two sidewalls: 16 times 25.4 plus twice 112.75 gives 631.9 mm. Multiply by pi and you get the circumference, 1985.2 mm, the distance covered in one turn. Divide one kilometre, 1,000,000 mm, by that circumference and the tire turns 503.73 times per kilometre. The most common mistake is treating the aspect ratio as millimetres, which makes the sidewall far too tall. Another is mixing inches and millimetres in the same sum. Lengths are rounded to one decimal by default, and you can choose anything from 0 to 3.

What you can do with it

Tire and wheel fitment tools

Compare the overall diameter of a stock and an aftermarket size to estimate ride-height and clearance changes.

FAQ

What tire code format is accepted?

Metric radial codes like 205/55R16: three-digit width in mm, two-digit aspect ratio, R, and two-digit rim in inches; extra rating suffixes are ignored.

How is revolutions per kilometre derived?

As 1,000,000 mm divided by the circumference in mm, and it is rounded to one more decimal place than the other outputs.

How do I work out a tire's sidewall height?

Multiply the width by the aspect ratio and divide by 100. For 205/55R16 that is 205 times 55 divided by 100, or 112.75 mm, shown as 112.8 mm with the default single decimal.

How is the overall diameter of a tire calculated?

Convert the rim size to millimetres by multiplying the inches by 25.4, then add two sidewalls. For 205/55R16 that gives 16 times 25.4 plus twice 112.75, which is 631.9 mm.

Can I use it to compare two tire sizes?

Yes. Calculate each size and compare the overall diameters to estimate how ride height and clearance would change. The circumference and revolutions per kilometre are the basis for estimating speedometer error with a different size.

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/dev/tire-size

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/dev/tire-size \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"code":"205/55R16"}'

const res = await fetch("https://api.kit.forhosting.com/dev/tire-size", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "code": "205/55R16"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/tire-size",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "code": "205/55R16"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/tire-size", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"code":"205/55R16"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"code":"205/55R16"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/tire-size", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "code": "205/55R16"
}

Example response

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

Parsing the metric tire code

Any trailing load and speed rating after the rim size is ignored, and the echoed code is trimmed to its first token and upper-cased. A string that does not fit this pattern throws a typed invalid_input error. From the three numbers it computes sidewall_mm = width_mm * aspect_ratio / 100, so for 205/55R16 the sidewall is 205 * 55 / 100 = 112.75 mm, rounded to 112.8 mm, exactly the shipped example output.

Diameter, circumference and revolutions

For 205/55R16 that is 16 * 25.4 + 2 * 112.75 = 631.9 mm. Overall diameter is the rim converted to millimetres plus two sidewalls: overall_diameter_mm = rim_inches * 25.4 + 2 * sidewall_mm. Circumference uses a locally defined constant PI (3.141592653589793): circumference_mm = PI * overall_diameter_mm, giving 1985.2 mm here. Revolutions per kilometre is 1e6 / circumference_mm, since one kilometre is 1,000,000 mm, yielding 503.73 for the example. The response also returns width_mm, aspect_ratio and rim_inches as parsed, plus the pi constant used, so a caller can verify or re-derive every figure. These outputs are the geometric basis for comparing tire sizes and estimating speedometer error when fitting a different size.

Rounding precision per field

The optional decimals parameter defaults to 1 and must be an integer from 0 to 3; an out-of-range or non-integer value throws invalid_input. sidewall_mm, overall_diameter_mm and circumference_mm are rounded half-up to that precision, while revolutions_per_km is rounded to decimals + 1 places, giving it one extra digit because it is a denser quantity where small differences matter for odometer comparisons. If the computed circumference is not finite or is not strictly positive the call raises invalid_input.

Integration use cases

Speedometer and odometer correction

Use revolutions_per_km from two tire codes to compute the percentage speedometer error after a size change.

Automotive catalogs and calculators

Batch a catalog of tire codes through the API to publish sidewall, diameter and circumference specs for each listing.

Technical questions

How is overall diameter calculated?

rim_inches * 25.4 plus two sidewalls, where each sidewall_mm is width_mm * aspect_ratio / 100.

What decimals precision can I request?

decimals is an integer from 0 to 3 (default 1); revolutions_per_km gets decimals + 1 places. Out-of-range values return invalid_input.

Is it free and what does the API cost?

The on-page widget is free (tier A) and runs the same deterministic core; API calls are billed per successful request from $0.002.

Read the full KIT documentation →

Run — free