Area of a circle calculator
A circle with a radius of 5 has an area of 78.539816, computed with the full value of π, 3.141592653589793, never a rounded 3.14. Choose how many decimals you need, from two for a paint job to twelve for science. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Radius
- 5
- Area
- 78.539816
- Pi
- 3.1415926536
Send a positive finite radius, get back the area, the radius you sent, the value of π used and the formula applied. The same deterministic code runs free in your browser on this page, so you only pay when you automate it.
One radius in, one exact area out
The contract is deliberately small. The π used is the full double-precision constant, 3.141592653589793, never a truncated 3.14, so the result you get is the same one a scientific library would give you. The radius is echoed back in the response together with the area, the π constant and the formula string, which makes the output self-documenting when you store it or forward it to another system.
The radius must be a positive finite number: zero is rejected because a circle of radius zero has no area worth reporting, negatives are rejected because a radius is a length, and NaN or Infinity are rejected because they are not measurements. Because the error is a client error, it is not billed — you only pay for requests that actually produce an area.
Where one exact formula saves time
In those settings the boring properties are the important ones — deterministic output, a strict validation contract, a fixed π, and a price you can predict. The capability runs on our global edge with nothing persisted after the response, so a radius you send exists only for the milliseconds of the computation. The identical code powers the free calculator on this page, which means the number you see in the browser is the number your script will get: try it by hand first, then automate with confidence.
What you can do with it
Estimate material for circular parts
Turn a list of radii from a CAD export into surface areas to price sheet material, fabric or coating per batch.
Validate supplier specifications
Check that the area a supplier reports is consistent with the radius they quote, catching unit mix-ups before an order.
Power a homework helper
Give students an authoritative worked answer for A = π·r² with the exact π and rounding used shown alongside.
FAQ
What formula is used?
A = π·r², with π at full double precision (3.141592653589793), rounded half-up to the decimals you choose.
Can I control the precision of the result?
Yes. The optional decimals field sets the number of decimal places, from 0 to 12; it defaults to 6.
Can I pass a diameter instead of a radius?
No. Divide the diameter by two before calling. The input contract is a radius only, which keeps the response unambiguous.
Why does my answer differ slightly from my textbook?
Many textbooks round π to 3.14, while this calculator uses the full value 3.141592653589793. The result therefore matches what a scientific library would give, and a short rounded π explains the small gap.
Why is a radius of zero or below rejected?
A circle with a radius of zero has no area worth reporting, and a negative radius makes no sense because a radius is a length. The calculator stops and asks for a positive number instead of returning a misleading area.
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/math/area-of-a-circle \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"radius":5}'const res = await fetch("https://api.kit.forhosting.com/math/area-of-a-circle", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"radius": 5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/area-of-a-circle",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"radius": 5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/area-of-a-circle", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"radius":5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"radius":5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/area-of-a-circle", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"radius": 5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.area_of_a_circle",
"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
The area of a circle API takes one number — the radius — and returns the area using the classic formula A = π·r², computed with the full double-precision value of π and rounded half-up to the number of decimal places you choose. It exists for the moment when you need that single result inside a script, a spreadsheet export or a build pipeline, without opening a calculator, without rounding π by hand and without re-implementing the same validation for the tenth time. Anything that is not a positive finite number — zero, negatives, text, missing fields — is rejected with a clear invalid_input error and is never charged.
One radius in, one exact area out
You pass a radius as a JSON number and receive the area of the circle that radius defines, computed as π multiplied by the radius squared. Each rejection comes back as an invalid_input error naming the offending field, so a calling script can surface the problem to its own user without parsing free text.
Why the rounding is configurable and deterministic
Half-up rounding means 2.5 goes to 3, matching what most people expect from school arithmetic rather than the banker's rounding some libraries apply silently. If you need more precision for a scientific workflow, ask for twelve decimals; if you are computing how much paint covers a circular floor, ask for two and get a number you can quote. Floating point arithmetic is famously host-dependent in its last bits, and an API whose output changes between machines is an API you cannot test against. This capability avoids that trap by rounding the raw product half-up to a configurable number of decimal places, six by default and anything from zero to twelve on request. The rounding never hides an overflow: if a radius is so large that the area stops being finite, the call fails with invalid_input instead of returning Infinity.
Where a single-formula API earns its keep
Nobody needs an API to multiply one number by itself once. The value appears when the call sits inside a loop or a pipeline: estimating material for thousands of circular parts, converting a column of radii into areas during a data import, validating that a reported radius implies the area a supplier claims, or teaching a student-facing tool where the worked answer must come from somewhere trustworthy. API usage is billed at $0.002 per request with no per-unit surcharge, and invalid inputs are rejected before billing.
Technical questions
What does it cost?
$0.002 per request. It is also free to run in your browser on this page.
What radius values are accepted?
Any positive finite number. Zero, negative values, text, NaN and Infinity are rejected with an invalid_input error and are not charged.