ForHosting KIT · Developer Utilities

Exterior angles of a triangle calculator

The exterior angles of a triangle API takes the three interior angles of a triangle, in degrees, and returns the exterior angle at each vertex — the angle formed by one side of the triangle and the extension of the adjacent side.

● BetaFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Before computing anything it verifies that the three angles are positive and add up to exactly 180 degrees, so the result always belongs to a real triangle and a malformed input is rejected instead of being silently turned into plausible-looking numbers.

What an exterior angle actually is

At every vertex of a triangle, one side arrives and another leaves. If you extend the arriving side straight past the vertex, the angle between that extension and the leaving side is the exterior angle. It is supplementary to the interior angle at the same vertex, which is the entire computational content of this capability: each exterior angle equals 180 degrees minus its adjacent interior angle. A 60-degree interior angle produces a 120-degree exterior angle, a right angle produces another right angle, and a very sharp 5-degree interior angle produces a very obtuse 175-degree exterior angle. Because the three interior angles of any triangle always sum to 180 degrees, the three exterior angles always sum to 360 degrees — the same full turn you would make if you walked around the triangle pivoting at each corner. The exterior angles of a triangle calculator returns both sums alongside the individual angles so the invariant is visible in the output, not just assumed.

Why the input is validated before anything is computed

Subtraction never fails, so an unvalidated calculator would happily report exterior angles for a triangle that cannot exist: give it 90, 90 and 90 degrees and naive arithmetic returns three 90-degree exterior angles for a figure that closes nowhere. That is worse than an error, because the numbers look reasonable. This endpoint checks the geometry first. Every angle must be a positive finite number of degrees and strictly less than 180 — a triangle vertex cannot be zero or flat — and the three together must sum to 180 degrees within a tight floating-point tolerance. If any check fails the request is rejected as invalid input with a message naming the offending field or the actual sum, and a rejected request is not billed. The validation is also what makes the result trustworthy downstream: a pipeline that receives exterior angles from this API knows the interior angles behind them described a genuine triangle.

How to call it and what you get back

Send the three interior angles as angle_a, angle_b and angle_c, in degrees, as numbers or numeric strings; common aliases such as a, b and c or alpha, beta and gamma are accepted too. The response echoes the interior angles, gives the three exterior angles in the same vertex order, and includes the interior and exterior sums. Everything is rounded to twelve decimal places so the JSON is byte-stable across machines and safe to compare in tests. There is no unit conversion to configure: degrees in, degrees out, which keeps the contract obvious for homework checkers, CAD preprocessors and geometry tutors alike. The same deterministic solver runs free in your browser on this page and behind the paid API at $0.002 per request, so the numbers you see while experimenting are exactly the numbers your production calls will return. No data is stored: the angles are read, checked, answered and forgotten.

What you can do with it

Check geometry homework in one call

Verify that three interior angles form a valid triangle and get each exterior angle without redoing the subtractions by hand.

Preprocess polygon data in a CAD pipeline

Reject malformed triangle definitions before they reach a mesh builder, and store the turning angles alongside the model.

Power a geometry tutor or quiz backend

Generate the exterior-angle answers for triangle exercises programmatically, with invalid problem sets caught at validation time.

FAQ

What does it cost?

$0.002 per request. It is also free to run in your browser on this page, with the same solver the API uses.

What is an exterior angle of a triangle?

The angle between one side of the triangle and the extension of the adjacent side. At each vertex it equals 180 degrees minus the interior angle at that vertex.

Why was my input rejected?

Either an angle was missing, non-numeric, not positive, or not below 180 degrees, or the three angles did not sum to 180 degrees. The error message says which check failed.

Do the exterior angles always sum to 360 degrees?

Yes. Since the interior angles sum to 180, the three exterior angles sum to 540 minus 180, that is 360 degrees. The response includes both sums so you can confirm it.

Can I pass radians instead of degrees?

No. The contract is degrees in, degrees out. Convert radians to degrees before calling (multiply by 180 and divide by pi).

Are the angles stored or logged?

No. The input is processed in memory and discarded; only the computed angles are returned.

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

POSThttps://api.kit.forhosting.com/math/exterior-angles-of-a-triangle

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/exterior-angles-of-a-triangle \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"angle_a":60,"angle_b":70,"angle_c":50}'

const res = await fetch("https://api.kit.forhosting.com/math/exterior-angles-of-a-triangle", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "angle_a": 60,
    "angle_b": 70,
    "angle_c": 50
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/math/exterior-angles-of-a-triangle",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "angle_a": 60,
    "angle_b": 70,
    "angle_c": 50
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/exterior-angles-of-a-triangle", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"angle_a":60,"angle_b":70,"angle_c":50}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"angle_a":60,"angle_b":70,"angle_c":50}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/exterior-angles-of-a-triangle", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "angle_a": 60,
  "angle_b": 70,
  "angle_c": 50
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "math.exterior_angles_of_a_triangle",
  "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

Per request$0.002

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.

Read the full KIT documentation →