Tsp to mL converter
2.5 US teaspoons are 12.322303984375 mL. Turn a teaspoon amount from a recipe, a nutrition record or a lab note into milliliters with one fixed factor, so you can measure it with a tool marked in milliliters. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 2.5
- Teaspoons
- 2.5
- Milliliters
- 12.3223039844
- Milliliters per teaspoon
- 4.9289215938
This tsp to mL converter changes a non-negative volume in US customary teaspoons into milliliters. Enter the teaspoon value and receive the equivalent metric volume using the precise factor of 4.92892159375 milliliters per teaspoon. The calculation is deterministic, immediate, and suitable for recipes, nutrition records, laboratory notes, and software tests. It accepts zero and decimal quantities, while rejecting negative values and inputs that are not finite numbers.
Enter the teaspoon volume you actually need to convert
Provide one value representing a volume in US customary teaspoons. Whole numbers such as one or three work, and decimal amounts such as 0.25, 1.5, or 2.75 are equally valid. Zero is accepted because an empty volume has a meaningful converted result of zero milliliters.
The input must be a real, finite number. Text labels, missing values, NaN, positive Infinity, and negative Infinity are rejected instead of being guessed or silently coerced. Negative quantities are also rejected because this converter describes a physical volume rather than a signed change in inventory.
The converter does not ask for a direction because this capability has one focused job: teaspoons go in and milliliters come out. It also does not select among teaspoon standards. The calculation consistently uses the US customary teaspoon, so repeated requests use the same documented definition.
If your source uses an exact five-milliliter metric teaspoon, account for that different convention before submitting the value rather than treating both standards as interchangeable. This explicit scope makes the response easy to audit and safe to reuse in deterministic tests.
Understand the fixed conversion and the returned fields
The converter multiplies the submitted teaspoon value by 4.92892159375, the number of milliliters in one US customary teaspoon. For example, two teaspoons are evaluated by multiplying two by that constant, while half a teaspoon uses exactly the same rule with 0.5. No exchange rate, locale setting, current date, random value, external service, or stored preference can alter the arithmetic.
JavaScript number precision applies, so the result is appropriate for ordinary cooking and measurement workflows but should not be presented as evidence that a kitchen spoon or measuring device has laboratory-grade accuracy. Clients may format the returned milliliter value for their audience while retaining the raw numeric result for subsequent calculations. This separation avoids cumulative error when several recipe amounts are scaled and summed before final presentation.
Use the result in recipes, records, and automated systems
A cook can use the converter when a recipe lists vanilla, oil, medicine flavoring, or another liquid in teaspoons but the available measuring tool is marked in milliliters. A nutrition application can normalize small US customary recipe quantities before combining them with metric serving data. Because the algorithm has no network dependency and no variable environmental inputs, the same valid value produces the same numeric response every time.
That predictability matters when a conversion runs in continuous integration or forms part of an audit trail. Validate the source convention before automating a large collection: some countries and nutrition systems use a metric teaspoon defined as exactly five milliliters, which differs slightly from the US customary factor used here. Also remember that a precise mathematical conversion cannot improve the precision of the original measurement.
If a recipe says roughly one teaspoon, the calculated milliliters remain an equivalent of that approximate input. Use reasonable display rounding for people, preserve the returned number for computation, and label the final value as milliliters so downstream users do not mistake it for teaspoons or grams.
What you can do with it
Adapt a US recipe
Convert teaspoon measurements into milliliters for a metric measuring cup, syringe, or scale-supported workflow.
Normalize recipe data
Turn imported US teaspoon volumes into consistent milliliter fields before scaling servings or combining ingredients.
FAQ
How many milliliters are in one teaspoon?
One US customary teaspoon equals 4.92892159375 milliliters, which is the fixed factor used by this converter.
Does this use a metric teaspoon?
No. It uses the US customary teaspoon. A metric teaspoon is commonly defined as exactly 5 milliliters.
Can I enter a decimal teaspoon value?
Yes. Any finite, non-negative numeric value is accepted, including zero and decimal quantities.
Can it convert teaspoons to grams?
No. It converts volume to volume only. Turning teaspoons into grams needs the density of the ingredient, and that changes from one ingredient to another, so no density is applied here.
Is the result rounded?
No. The milliliter value is returned without display rounding, so you can scale and add several recipe amounts first and round only the final figure, which avoids building up small errors.
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/conv/tsp-ml-converter \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":2.5}'const res = await fetch("https://api.kit.forhosting.com/conv/tsp-ml-converter", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 2.5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/tsp-ml-converter",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 2.5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/tsp-ml-converter", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":2.5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":2.5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/tsp-ml-converter", 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": 2.5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.tsp_ml_converter",
"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
Run it in the browser for quick checks, or use the API for $0.002 per request when a repeatable conversion belongs in an automated workflow.
Enter the teaspoon volume you actually need to convert
Keeping the contract narrow prevents ambiguous results when the value comes from a spreadsheet, form, recipe importer, or API client.
Understand the fixed conversion and the returned fields
The response returns the original value as teaspoons, the computed equivalent as milliliters, and the factor as milliliters_per_teaspoon. Returning the factor alongside the answer makes the result self-describing: a reviewer can see which convention was applied without consulting hidden state or reconstructing the request. The endpoint performs no density calculation and therefore cannot turn teaspoons into grams; mass depends on the ingredient. It also does not round to a display-specific number of decimal places.
Use the result in recipes, records, and automated systems
Interactive use in the browser is convenient for individual checks, while an API request costs $0.002 when the conversion needs to be incorporated into a program.
Integration use cases
Create deterministic test fixtures
Produce stable teaspoon-to-milliliter outputs for application tests without duplicating the conversion constant.
Technical questions
What happens with a negative or non-finite value?
The request fails with an invalid_input error instead of returning a misleading volume.
What does an API conversion cost?
Each successful API request costs $0.002. You can also run the browser version for an interactive conversion.