Arccotangent in degrees calculator
The arccotangent of 1 is 45°, of 0 is 90° and of −1 is 135°. Enter any finite real number and get its single principal inverse cotangent angle in degrees, always between 0 and 180. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 1
- Degrees
- 45
- Principal range
- (0°, 180°)
This arccotangent in degrees calculator finds the principal inverse cotangent angle for any finite real number. Enter a positive, negative, or zero value and receive one unambiguous angle in the standard range between zero and one hundred eighty degrees. Positive values produce acute angles, zero produces ninety degrees, and negative values produce obtuse angles.
Understand the principal arccotangent branch
Cotangent repeats every one hundred eighty degrees, so infinitely many angles can share the same cotangent. An inverse cotangent calculator must therefore choose a single branch before it can return a function-like answer. This capability uses the standard principal range from zero to one hundred eighty degrees.
A value of one returns forty-five degrees because cotangent of forty-five degrees is one. Zero returns ninety degrees because cosine is zero while sine is one there. A value of minus one returns one hundred thirty-five degrees, preserving the negative cotangent in the second quadrant.
This branch convention is particularly useful because it covers every real cotangent value exactly once. The response includes a principal-range label so worksheets, programs, and audit records do not have to infer which competing convention was selected. The result is the representative principal angle, not every coterminal solution.
To express the full solution family afterward, add integer multiples of one hundred eighty degrees to the returned angle according to the needs of the surrounding equation.
How the calculator validates and computes the result
Provide one field named value containing a finite real number. Once validation succeeds, the calculator evaluates atan2 with one as the vertical component and the supplied value as the horizontal component, then converts the resulting radians to degrees. This formulation directly returns an angle between zero and one hundred eighty degrees.
It avoids the common mistake of calculating atan of one divided by the value without correcting the branch for negative inputs, and it handles zero without division. No tolerance, clamping, or guessed replacement is applied: the finite number you submit is the number used. Very large positive values approach zero degrees, and very large negative values approach one hundred eighty degrees, while remaining inside the principal interval.
Because the implementation uses a fixed arithmetic path with no network, model, random source, stored state, or current-time dependency, repeating the same request produces the same structured result.
Use inverse cotangent results correctly
Use this calculator when a problem supplies a cotangent ratio, a reciprocal slope, or an adjacent-to-opposite relationship and asks for the corresponding principal angle in degrees. It fits right-triangle exercises when the sign and chosen branch match the stated geometry, analytic trigonometry checks, engineering worksheets, and automated answer validation. Read the output as degrees; do not pass it into a library expecting radians unless you deliberately convert it.
Also distinguish arccotangent from arctangent. Although arccot(x) and arctan(1/x) can describe related acute angles, a simple reciprocal formula loses the intended branch when x is negative and is undefined at zero. The direct branch-aware computation used here handles all finite real values consistently.
In a broader equation, remember that cotangent is periodic, so the principal result may be only the first step. Add multiples of one hundred eighty degrees when every solution is required, and apply any interval restrictions from the original problem afterward. For vector directions with separate horizontal and vertical components, an atan2 calculator may communicate quadrant information more directly than forming a quotient.
What you can do with it
Solve inverse-cotangent exercises
Convert a supplied cotangent value into its standard principal angle in degrees for homework or answer checking.
Recover an angle from a ratio
Turn an adjacent-to-opposite ratio into a branch-aware degree result without dividing by zero or correcting negative inputs manually.
FAQ
What values can I enter?
Enter any finite real number, including positive values, negative values, and zero.
What range does arccotangent use?
The principal angle is strictly between 0° and 180° for every finite real input.
What is arccotangent of zero?
It is 90° under the standard principal branch because cotangent of 90° is zero.
Why not calculate arctangent of one divided by the value?
That shortcut is undefined at zero and needs a branch correction for negative inputs. The calculator uses a direct atan2 formulation.
What is the arccotangent of −1 in degrees?
It is 135 degrees. A negative value gives an obtuse angle in the second quadrant, while a positive value such as 1 gives an acute angle of 45 degrees.
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/arccot-degrees \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":1}'const res = await fetch("https://api.kit.forhosting.com/trig/arccot-degrees", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/trig/arccot-degrees",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/trig/arccot-degrees", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/trig/arccot-degrees", 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": 1
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "trig.arccot_degrees",
"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 calculation is deterministic, validates malformed and non-finite input, uses no network service, and is available through the API for $0.002 per request.
Understand the principal arccotangent branch
For every finite real input, the returned angle lies strictly inside that range: neither endpoint occurs because cotangent approaches positive or negative infinity near those boundaries rather than reaching an infinite real input.
How the calculator validates and computes the result
JSON numbers are the clearest API representation, while trimmed decimal strings and scientific notation are also accepted for convenient text-form input. Missing values, empty strings, arbitrary text, NaN, positive infinity, and negative infinity are rejected with an invalid_input error instead of producing a misleading angle. The response echoes the parsed value, reports degrees, and identifies the selected principal range.
Use inverse cotangent results correctly
Each API request processes one value as one item and costs $0.002. The browser and API execution paths share the same pure solver, making the tool suitable for reproducible examples and programmatic checks.
Integration use cases
Create deterministic test fixtures
Generate reproducible principal arccotangent values for calculators, educational software, and numerical test suites.
Technical questions
How much does an API request cost?
Each request costs $0.002 and processes one input value as one item.