ForHosting KIT · Math

Triangle type by angles

Enter three interior angles and see whether the triangle is acute, right or obtuse: 60°, 60° and 60° is acute, 90°, 45° and 45° is right, and 120°, 30° and 30° is obtuse. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Angle a: 60
Angle b: 60
Angle c: 60

You get

Sum degrees: 180
Max angle: 60
Triangle type: acute
Unit angles: deg

Classifying a triangle by its interior angles is one of the first geometry skills taught in school and one of the checks that CAD scripts, exam generators, and homework checkers still need every day. Given three measures in degrees, a plane triangle is acute when every angle is less than ninety degrees, right when one angle is exactly ninety degrees, and obtuse when one angle is greater than ninety degrees. Those labels only make sense when the three numbers are positive, each strictly less than one hundred eighty degrees, and sum exactly to one hundred eighty degrees—the Euclidean angle sum.

How angle classification works in plane geometry

In Euclidean plane geometry the three interior angles of any non-degenerate triangle sum to exactly one hundred eighty degrees. That single identity is the gate before any type label is trustworthy: if your three measures do not add to one hundred eighty, they do not describe a plane triangle at all, and labeling them acute or obtuse would be misleading. Once the sum is correct and every angle lies strictly between zero and one hundred eighty degrees, the type follows from the largest angle alone.

If the largest is less than ninety degrees, every angle is acute and the triangle is acute; if the largest is exactly ninety degrees, the triangle is right; if the largest is greater than ninety degrees, exactly one angle is obtuse and the triangle is obtuse (a plane triangle cannot have two obtuse angles, because two measures each greater than ninety would already exceed the one-hundred-eighty sum).

Equilateral and equiangular examples such as sixty-sixty-sixty are acute; the classic forty-five-forty-five-ninety isosceles right triangle is right; one hundred twenty with thirty and thirty is obtuse. Side-length classifications (scalene, isosceles, equilateral) are a different SEO intent and a different capability family: this tool answers only the angle-based question people search as triangle type by angles, acute right or obtuse triangle, and classify triangle from angles. Degrees are the unit throughout; convert from radians upstream if your source data is in radians.

What you can do with it

Classroom and homework checks

Let students submit three interior angles and verify the acute, right, or obtuse label against the angle-sum rule and the largest-angle test.

CAD and game geometry branches

Classify known interior-angle triples before choosing a right-triangle construction path or an obtuse-triangle UV layout without a full geometry stack.

FAQ

Can an angle be zero, negative, or 180°?

No. Each interior angle must be strictly greater than 0° and strictly less than 180°.

Does this tool classify by side lengths too?

No. It only classifies by angles (acute, right, obtuse). Scalene, isosceles, and equilateral labels from side lengths are a different problem and a different capability.

What happens if the angles do not add up to 180?

The calculation is refused, because three measures that do not sum to 180 degrees do not describe a plane triangle, and calling them acute or obtuse would be misleading.

How is the type decided from three angles?

Once the sum is right, only the largest angle matters: below 90 degrees the triangle is acute, exactly 90 makes it right, and anything above 90 makes it obtuse.

Can a triangle have two obtuse angles?

No. Two angles each larger than 90 degrees would already exceed the 180-degree sum on their own, so a plane triangle has at most one obtuse angle.

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

POSThttps://api.kit.forhosting.com/geom/triangle-type-angles

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

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

import os, requests

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

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

body := bytes.NewBufferString(`{"angle_a":60,"angle_b":60,"angle_c":60}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/geom/triangle-type-angles", 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": 60,
  "angle_c": 60
}

Example response

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

Technical notes

This triangle type by angles classifier accepts angle_a, angle_b, and angle_c, validates that contract, and returns the type together with the echoed angles, the sum, and the largest angle. Invalid triples fail with invalid_input instead of a silent wrong label.

Input contract, response shape, and error behaviour

Every angle must be strictly greater than zero and strictly less than one hundred eighty degrees—zero, negative, or flat one-hundred-eighty measures do not form an interior angle of a non-degenerate triangle. Failed validation is not billed. POST a JSON body with three required finite numbers: angle_a, angle_b, and angle_c, each an interior measure in degrees. Aliases A, B, C, angle1 through angle3, and alpha, beta, gamma are accepted so scripts that already use textbook labels do not need a rename step. Each field may arrive as a JSON number or as a numeric string; missing fields, empty strings, and non-finite values fail with invalid_input naming the field. On success the body echoes the three angles, reports sum_degrees and max_angle, sets triangle_type to acute, right, or obtuse, includes unit_angles as deg, and adds a short formula string you can show next to the answer. Example: sixty, sixty, sixty yields acute with max_angle sixty; ninety, forty-five, forty-five yields right; one hundred twenty, thirty, thirty yields obtuse. The endpoint does not solve for a missing third angle from two known ones—that is a different solver—and it does not classify by side lengths.

Where a triangle type by angles API earns its keep

Classrooms and tutoring platforms use a triangle type by angles classifier so learners can check acute, right, and obtuse labels for arbitrary textbook triples without mixing up the angle-sum rule with the side-length rules. Exam-prep generators and LMS auto-graders need a deterministic oracle that marks wrong any triple that does not sum to one hundred eighty instead of silently returning a type a buggy student script might treat as success. CAD macros, game tools, and simple geometry notebooks often know three interior angles from a sketch or a constraint solver and only need a one-word type before branching on which construction or texture set to apply; calling a tiny parse API avoids pulling a full geometry library for three comparisons. Keep requests small, pin the triangle_type string in tests, and you get reproducible classification for homework, LMS plugins, and edge workers without standing up symbolic math infrastructure of your own.

Integration use cases

Exam and LMS auto-grading

Mark triangle-type items with a deterministic oracle that rejects non-180 sums as invalid_input and never invents a type for illegal triples.

Technical questions

How do I classify a triangle from three angles?

Send finite degrees angle_a, angle_b, and angle_c that sum to 180. The API returns triangle_type acute if the largest angle is under 90°, right if it is 90°, and obtuse if it is over 90°.

What happens if the angles do not sum to 180?

The task fails with invalid_input and reports the actual sum. Those three numbers do not form a plane triangle, so no type is returned and the call is not billed.

What does the triangle type by angles classifier cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free