ForHosting KIT · Engineering & construction

Equilibrant force calculator

Forces of (3, 4) and (−1, 2) add up to a resultant of (2, 6), so the force that balances them is (−2, −6), with the same size and the opposite direction. Enter each force by its components to get the equilibrant. 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

When several forces act in one plane on a particle or a structure, static equilibrium requires a balancing force that cancels their vector sum. That balancing force is the equilibrant: equal in magnitude to the resultant and opposite in direction. Students, tutors, and analysis scripts often receive forces as rectangular components rather than polar pairs, so they need a deterministic path from a list of Fx and Fy values to the single equilibrant vector, its magnitude, and its polar angle. This equilibrant force calculator accepts a non-empty array of coplanar force components, sums them into a resultant, and returns the equal-and-opposite equilibrant with stable rounded numbers suitable for homework checks and automated grading.

What an equilibrant is and how it relates to the resultant

In plane statics the resultant R of a set of concurrent coplanar forces is the single force that has the same effect as the whole set acting together. Component-wise, if each force is written F_i = (F_ix, F_iy), the resultant components are simply R_x equals the sum of all F_ix and R_y equals the sum of all F_iy. The magnitude of R is the Euclidean hypotenuse of those two sums, and its direction is the two-argument arctangent of R_y and R_x measured from the positive x-axis.

Equilibrium of a particle requires that the net force vanish, so the additional force E that must be applied to cancel R is the opposite vector: E equals negative R. Therefore E_x equals negative R_x, E_y equals negative R_y, the magnitude of E equals the magnitude of R, and the polar angle of E differs from that of R by one hundred eighty degrees (modulo a full turn).

This is not a free-body diagram generator and it does not locate lines of action for non-concurrent systems; it answers the component question students and engineers type into an equilibrant force calculator every day: given these Fx and Fy values, what single force balances them. When every supplied force is already zero, the resultant and equilibrant are both the zero vector, which is a valid equilibrium statement rather than an error.

Who needs the equilibrant force and why

Mechanics classrooms and tutoring platforms use an equilibrant force calculator so learners can check component sums without sign errors when preparing for exams on concurrent coplanar systems. Learning-management plugins need a deterministic oracle that rejects empty force lists and never silently returns a fake balance. Failed validation does not consume balance.

Keep requests small, pin the rounded vectors in tests, and you get reproducible equilibrants for homework, LMS plugins, and edge workers without standing up a general-purpose mechanics engine of your own.

What you can do with it

Classroom statics checks

Let students submit coplanar Fx and Fy tables and verify the single equilibrant that balances the resultant before they redraw the free-body diagram.

LMS and exam auto-grading

Score concurrent-force items with a deterministic oracle that rejects empty force lists and matches magnitude and angle within stable rounded precision.

Planar load notebooks

Reduce small Fx/Fy load tables to one balancing force in design scripts without importing a full multi-body or finite-element stack.

FAQ

How do I find the equilibrant of coplanar forces?

Send a non-empty forces array of {fx, fy} components.

What happens if I supply no forces?

An empty or missing forces list is not treated as a zero-load success case and is not billed.

Is the equilibrant the same as the resultant?

No. The resultant R is the vector sum of the given forces. The equilibrant is equal in magnitude and opposite in direction: E = −R.

Which angle convention does the calculator use?

Angles are mathematical degrees from the positive x-axis via atan2(y, x), in (−180, 180]. A zero vector reports angle 0.

How many forces can I enter?

At least one and up to 100, each written as an x and a y component in the same unit, such as newtons. The tool adds them all and then reverses the total to give the balancing force.

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/mech/equilibrant-force

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/mech/equilibrant-force \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"forces":[{"fx":3,"fy":4},{"fx":-1,"fy":2}]}'

const res = await fetch("https://api.kit.forhosting.com/mech/equilibrant-force", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "forces": [
      {
        "fx": 3,
        "fy": 4
      },
      {
        "fx": -1,
        "fy": 2
      }
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/mech/equilibrant-force",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "forces": [
        {
            "fx": 3,
            "fy": 4
        },
        {
            "fx": -1,
            "fy": 2
        }
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/mech/equilibrant-force", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"forces":[{"fx":3,"fy":4},{"fx":-1,"fy":2}]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"forces":[{"fx":3,"fy":4},{"fx":-1,"fy":2}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/mech/equilibrant-force", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "forces": [
    {
      "fx": 3,
      "fy": 4
    },
    {
      "fx": -1,
      "fy": 2
    }
  ]
}

Example response

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

Missing or empty force lists fail with invalid_input instead of inventing a zero load case.

Input contract, response shape, and error behaviour

At least one force is required and at most one hundred forces are accepted so a free parse worker path stays bounded. Angles are in degrees in the open-closed interval from negative one hundred eighty to positive one hundred eighty using the mathematical atan2 convention, with angle zero when both components are zero. Numeric fields are rounded to twelve decimal places for stable goldens across runtimes. Example: forces three comma four and negative one comma two sum to resultant two comma six with magnitude about six point three two five; the equilibrant is negative two comma negative six with the same magnitude and the opposite polar direction. POST a JSON body with a required forces array of objects, each carrying finite numbers fx and fy in one consistent unit system such as newtons. Common aliases force_x, force_y, x, and y are accepted on each record; the list itself also accepts force_list and vectors as transport aliases. Empty arrays, missing forces, non-objects in the list, and non-finite components fail with invalid_input and are not billed. On success the body echoes force_count and the cleaned force list; reports resultant_fx, resultant_fy, resultant_magnitude, and resultant_angle_deg; and reports the matching equilibrant_fx, equilibrant_fy, equilibrant_magnitude, and equilibrant_angle_deg. Pair the numbers with your own free-body sketch if you need graphics; this endpoint returns vectors and scalars only.

Where an equilibrant force API earns its keep

Structural and machine-design notebooks often reduce planar load cases to Fx and Fy tables before drawing the final balancing arrow on a free-body diagram; calling a tiny parse API avoids pulling a full multi-body solver for a few dozen components.

Technical questions

What does the equilibrant force calculator 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