Arccosine calculator
The arccosine of 0.5 is 60°, or 1.047197551197 radians, and both come back together so you never have to switch calculator modes. Values outside −1 to 1 are refused with a clear message instead of a silent error. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 0.5
- Radians
- 1.0471975512
- Degrees
- 60
- Unit radians
- rad
- Unit degrees
- deg
When you know a cosine value and need the angle that produced it, the inverse cosine—also written arccos or acos—is the closed-form tool that recovers the principal angle without drawing or iteration. This calculator accepts one finite number in the closed interval from negative one to one, applies the principal arccosine, and returns the result in both radians and degrees so classroom work and engineering pipelines share one stable contract.
How arccosine recovers the principal angle from a cosine
The cosine function maps every real angle to a value in the closed interval from negative one to one. In degrees that same principal range is zero through one hundred eighty. Edge cases are textbook checks: acos of one is zero, acos of zero is pi over two (ninety degrees), and acos of negative one is pi (one hundred eighty degrees).
Intermediate values such as one half yield pi over three (sixty degrees), and the square root of two over two yields pi over four (forty-five degrees). Because the service uses a single standard-library inverse cosine and a linear conversion from radians to degrees, the path is fully deterministic: the same cosine always produces the same pair of angles within floating-point rounding.
Where inverse cosine shows up in real work
Secondary-school and college trigonometry courses constantly ask students to recover an angle from a known cosine ratio; a trusted calculator with a strict domain check speeds homework grading and removes spreadsheet mistakes where someone applies acos to a cosine slightly outside the legal range and receives NaN. Robotics, computer graphics, and game physics often compute a cosine of an angle between two vectors and then need the unsigned principal angle for constraints, IK joints, or camera orientation—having a shared numeric oracle keeps engine code and design tools aligned.
Surveying and construction workflows convert direction cosines into bearings when only a ratio is measured. If you later need arcsine, arctangent, two-argument atan2, multi-branch inverses, or complex arccosine, treat those as separate search intents rather than overloading this arccosine landing.
What you can do with it
Homework and exam checks
Recover the principal arccosine of a cosine ratio in degrees and radians, and reject out-of-domain values with a clear error instead of NaN.
Robotics and graphics angles
Convert a direction-cosine or dot-product ratio into the principal angle for joints, constraints, and camera orientation.
FAQ
What does this calculator compute?
It returns the principal arccosine of a real value x in [-1, 1]: the unique angle theta in [0, π] such that cos(theta) = x, reported in both radians and degrees.
What is the allowed input range?
The cosine value must be a finite number in the closed interval from −1 to 1 inclusive.
What is the principal range of arccosine?
From 0 to π radians, which is 0 to 180 degrees. That is the standard single-valued branch used by Math.acos and most textbooks.
What does it cost?
The browser tool is free and runs locally.
What is arccos of 0.5?
It is 60 degrees, or about 1.047197551197 radians. The cosine of 60° is 0.5, and 60° is the only angle in the principal range, from zero up to a straight angle, with that cosine.
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/trig/inverse-cos \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":0.5}'const res = await fetch("https://api.kit.forhosting.com/trig/inverse-cos", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 0.5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/trig/inverse-cos",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 0.5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/trig/inverse-cos", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":0.5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":0.5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/trig/inverse-cos", 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": 0.5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "trig.inverse_cos",
"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 the legal domain, non-finite numbers, and missing fields are rejected with invalid_input instead of a silent NaN. The free browser tool and the paid API share one pure function, so demos and automated scripts never diverge on the same input.
How arccosine recovers the principal angle from a cosine
The inverse cosine undoes that map for a single principal value: for a real number x in that interval, acos of x is the unique angle theta in the closed interval from zero to pi such that cosine of theta equals x. There is no sampling, no series expansion you control, and no network call—only validation, one acos evaluation, and a stable rounded JSON payload.
What you send and what you get back
The number must lie in the closed interval from negative one to one inclusive. Example checks: value zero point five yields sixty degrees and pi over three radians; value zero yields ninety degrees; value one yields zero; value negative one yields one hundred eighty degrees; value one point five fails the domain gate. Wire the free browser tool for quick sanity checks, then call the identical contract from scripts when you need bulk arccosine conversion without reimplementing the domain gate in every language. Provide one required finite number under the field value, with aliases x, cos, cosine, and input for friendlier form labels. Missing fields, empty strings, non-numeric text, NaN, and Infinity are rejected with invalid_input and are not charged. If the number is finite but less than negative one or greater than one, the error message names the field and the out-of-range value so clients can correct the input without guessing whether equality at the endpoints was allowed. On success the JSON response echoes the normalized value, returns radians as the principal arccosine in the range zero to pi, returns degrees as that same angle scaled by one hundred eighty over pi, sets unit_radians to rad and unit_degrees to deg, and includes method as the string arccosine for logs and teaching UIs.
Where inverse cosine shows up in real work
Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance.
Integration use cases
Deterministic test fixtures
Generate stable acos(x) fixtures for unit tests and documentation with the same pure function in browser and API.
Technical questions
Are angles in degrees or radians?
Both. The response includes radians (unit_radians: "rad") and degrees (unit_degrees: "deg") so you can pick the unit your pipeline needs.