ForHosting KIT · Unit converters

Drill bit size converter

A number 7 drill is 0.201 in, 5.1054 mm or 201 mils, closest to a 13/64 fractional bit. Enter a number, letter, fraction or measured diameter and get every equivalent plus the nearest chart sizes. 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

Value: 7
From: number

You get

Value: 7
From unit: number
Diameter in: 0.201
Diameter mm: 5.1054

A drill bit size converter maps the four common shop notations for twist-drill diameter into one consistent set of results. Enter a numbered gauge from one through eighty with from equal to number, a letter size A through Z with from equal to letter, a fractional inch such as one quarter or three eighths with from equal to fraction, or a measured diameter in millimetres, decimal inches, or mils. The tool returns diameter in inches, millimetres, and mils, the nearest ANSI number gauge and letter with exact-match flags, and the nearest sixty-fourth fractional-inch label. Chart values use standard jobber drill diameters; linear units use the exact factor twenty-five point four millimetres per inch.

Number, letter, fraction and metric notations explained

Machinists and hardware catalogs still juggle four parallel naming systems for the same physical diameter. Numbered drills run from number one at roughly zero point two two eight inches down to number eighty at zero point zero one three five inches; higher numbers are smaller bits, which confuses newcomers who expect gauge to grow with size. Letter drills fill the band above number one: letter A is about zero point two three four inches and letter Z about zero point four one three inches, stepping through the alphabet.

Fractional inch bits remain the language of wood shops and general construction—one sixteenth, one eighth, one quarter, three eighths, one half, and so on—usually stocked in sixty-fourths of an inch increments on full imperial sets. Metric jobber drills are specified directly in millimetres and dominate ISO tooling lists. This converter holds the ANSI-style number and letter diameter tables, reduces fractions to a nearest sixty-fourth label, and multiplies or divides by twenty-five point four for millimetre and mil conversions.

It does not invent tap-drill recommendations, clearance-hole charts, or material-specific speeds and feeds; those need pitch, class of fit, and work-material data beyond diameter alone. Treat letter and number results as the chart sizes your index cabinet or digital caliper should match, then confirm specialty carbide or micro-drill catalogs when you leave the everyday jobber range.

What you can do with it

Shop index and drawer labels

Translate a worn number or letter stamp into millimetres and a fractional label before reprinting drawer tags and shadow-board stickers.

CAD and CNC notes

Map imperial bit callouts on older drawings to millimetre diameters for SI tool libraries and CAM diameter fields.

Receiving and kit audits

Convert a caliper reading in mm or mils back to the nearest number or letter size when matching purchase orders to bin stock.

FAQ

Which drill size systems are supported?

Number gauge #1–#80, letter A–Z, fractional inch (nearest 64th), millimetres, decimal inches, and mils.

How are number and letter diameters defined?

From standard ANSI/ASME jobber drill charts stored as fixed inch tables. Metric and mil values use the exact factor 25.4 mm per inch.

Does this recommend tap drills or speeds?

No. It only converts diameter notations. Tap charts need thread pitch and fit class; speeds need material and flute data.

Is the drill bit size converter free?

The browser tool is free and runs locally.

Why is a number 80 drill smaller than a number 1?

The numbered gauge runs backwards: the higher the number, the smaller the bit, so number 80 is the finest in the set. Letter drills then continue above number 1, from A up to Z.

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/conv/drill-bit-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/conv/drill-bit-size \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"value":"7","from":"number"}'

const res = await fetch("https://api.kit.forhosting.com/conv/drill-bit-size", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "value": "7",
    "from": "number"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/conv/drill-bit-size",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "value": "7",
    "from": "number"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/drill-bit-size", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"value":"7","from":"number"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"value":"7","from":"number"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/drill-bit-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

{
  "value": "7",
  "from": "number"
}

Example response

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

Unknown unit names and out-of-range gauges are rejected with invalid_input so scripts never invent a phantom bit.

How to call the API and what comes back

When from is number, value must be an integer from one through eighty, optionally written with a hash prefix. When from is letter, value is a single letter A through Z. When from is fraction, value may be a simple fraction, a mixed number such as one and one half, or a positive decimal inch length. When from is mm, in, or mils, value is a positive finite diameter in that unit with absolute magnitude at most one million. Send a JSON body with two required fields: value and from. Value may be a number or a string so letter drills and mixed fractions stay readable; from selects the source unit among number, letter, fraction, mm, in, and mils, with common aliases such as gauge, letter drill, fractional inch, millimetre, inch, and thou. On success the response echoes value and from, sets diameter_in, diameter_mm, and diameter_mils, reports number_gauge with number_label and number_exact, letter with letter_exact, fraction with fraction_decimal and fraction_exact, plus formula, message, steps, and supported_units. Failed validation—missing fields, non-finite magnitudes, letter outside A–Z, number outside one to eighty, non-positive diameters, or an unknown unit string—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item.

Practical tips, limits, and related searches

Fractional inputs that are not exact sixty-fourths still produce a nearest sixty-fourth label so cutting lists stay printable. Letter and number nearest matches report a signed delta in inches when the input diameter does not land on a table row, which is normal for odd metric sizes. This landing targets people searching for a drill bit size converter, number drill to millimetres, letter drill chart online, fractional inch bit to mm, or number seven drill size; it is not a wire-gauge calculator, not a screw-gauge tool, and not a sheet-metal gauge chart—those are separate KIT capabilities with different tables. Prefer the six canonical from tokens number, letter, fraction, mm, in, and mils when you control the client; free-form aliases help humans but automation should stay on the short ids. Round-trip checks are straightforward: convert number seven from number, read diameter_mm, then call again with that millimetre value and from equal to mm and confirm number_gauge returns seven with number_exact true within the published tolerance. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when you deliberately probe unknown units or range edges. Keep diameters positive and within the published absolute limit so edge cases stay predictable across Worker and browser.

Technical questions

What if my metric size is not on the imperial chart?

You still get diameter_in and diameter_mm exactly; number_gauge and letter are the nearest table rows with number_exact and letter_exact set false.

Read the full KIT documentation →

Run — free