Probability to fraction converter
A probability of 0.25 becomes the reduced fraction 1/4, and 0.375 becomes 3/8. Enter any probability from 0 to 1 and get the simplified numerator and denominator, ready for an answer key or a phrase like three in eight. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Probability
- 0.25
- Numerator
- 1
- Denominator
- 4
- Fraction
- 1/4
A probability is a number between zero and one, but textbooks, exams, and many statistical reports prefer the same value written as a reduced fraction. This probability to fraction converter takes a single probability in the closed unit interval and returns the fully simplified numerator and denominator, so one quarter stays one over four and one third is recovered as one over three instead of a long repeating decimal.
How a probability becomes a reduced fraction
Kolmogorov’s first axiom says a probability is a real number in the closed interval from zero to one. Writing that number as a reduced fraction n over d makes the same fact readable as “n equally likely outcomes out of d”, which is how most classroom problems, contest solutions, and many published tables already speak. This calculator turns the decimal or floating-point form back into that pair.
Finite decimal strings such as 0.25 are read exactly as an integer over a power of ten and then cancelled by the Euclidean greatest common divisor, so twenty-five hundredths becomes one fourth and 0.375 becomes three eighths. Zero maps to zero over one and one maps to one over one; both are valid probabilities, not errors. The response always echoes the cleaned probability, the reduced numerator, the reduced denominator, a printable fraction string, a simplified flag that is always true after reduction, and the identity p equals numerator over denominator.
What to enter and why the range is strict
Send exactly one of those names so a client cannot accidentally ship two conflicting figures. After parsing, the engine enforces the closed unit interval: any number strictly less than zero or strictly greater than one fails with a clear message that probability must lie between zero and one inclusive. That check is the product difference versus a general decimal-to-fraction tool.
A leftover percentage such as twenty-five, a residual score that slightly overshoots one after floating-point work elsewhere, or a signed residual from a spreadsheet formula is a data bug, not a probability, and clamping it would hide the mistake inside a plausible looking fraction. On success the body includes the cleaned probability, numerator, denominator, the fraction string, simplified true, and the formula string.
Where a probability fraction shows up in real work
Contest and textbook authors want one fourth, not 0.25000000000000006, when they typeset an answer key. Product and research teams often store conversion rates as unit-interval floats but publish them as “three in eight visitors”, which is exactly a reduced numerator and denominator. Quality and reliability notes quote defect chances as one in n rather than a long decimal.
Keep requests small, pin the reduced pair in tests, and you get reproducible answers for homework, LMS plugins, and edge workers without standing up a computer-algebra library of your own. If you later need a general decimal-to-fraction converter, a percent-to-fraction converter, or an odds converter, treat those as separate search intents and landings rather than overloading this probability-specific page.
What you can do with it
Classroom probability-to-fraction drills
Let students submit a decimal chance in [0, 1] and check the reduced numerator and denominator, including the certainty and impossibility edge cases.
Publish rates as “n in d” copy
Turn a stored conversion or defect probability into a simplified fraction for reports, captions, and answer keys without hand reduction.
FAQ
How do you convert a probability into a fraction?
Send a value in [0, 1]. The response is the reduced numerator and denominator.
What happens if the probability is outside 0 to 1?
Values strictly below 0 or above 1 are not valid probabilities and are not charged.
Will 0.333 become 1/3?
A string 0.333 is the exact decimal 333/1000.
Are probability 0 and probability 1 allowed?
Yes. Zero becomes 0/1 (impossible event) and one becomes 1/1 (certain event). Both are valid successes.
What does a call cost?
The browser tool is free and runs locally.
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/stat/probability-fraction \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"probability":0.25}'const res = await fetch("https://api.kit.forhosting.com/stat/probability-fraction", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"probability": 0.25
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/stat/probability-fraction",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"probability": 0.25
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/stat/probability-fraction", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"probability":0.25}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"probability":0.25}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/stat/probability-fraction", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"probability": 0.25
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "stat.probability_fraction",
"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
Values outside zero to one are rejected with invalid_input rather than silently clamped, so a leftover percentage such as twenty-five never becomes a fake fraction. Successful API calls are priced at the published base of $0.002 per item; validation failures are not charged.
How a probability becomes a reduced fraction
JSON numbers take the continued-fraction path: successive integer parts build convergents until the approximation sits inside a tight relative tolerance of the original float, which is how one third, two thirds, and one seventh survive IEEE-754 rounding instead of expanding into an enormous unreduced decimal fraction.
Input contract, aliases, and why the range is strict
POST a JSON body with the required field named probability, or use one of the classroom and form aliases p, prob, or chance. The value may arrive as a JSON number or as a numeric string; empty strings, missing fields, non-numeric text, NaN, and Infinity fail with invalid_input naming the field. Classic checks include 0.25 yielding one over four, 0.5 yielding one over two, and a JSON one third yielding one over three. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance and return the same invalid_input code the rest of the catalog uses for client-side mistakes.
Where a probability fraction shows up in real work
Secondary-school and college probability units constantly ask students to write a decimal chance as a simplified fraction, and a single trusted oracle that returns cleaned JSON speeds grading, demo setup, and interactive lesson design. Curriculum authors building browser widgets want the same JSON shape free on the page and paid through the API so offline worksheets and online auto-graders stay aligned. Because this capability is a pure parse engine, every successful call costs the published $0.002 base price with no model tokens and no outbound network, and failed validation does not consume balance.
Integration use cases
Grading fixtures and simulation checks
Generate deterministic expected fractions for unit tests, LMS auto-graders, and Monte Carlo harnesses that pin a rational chance.