ForHosting KIT · Science

Excess electrons calculator

A charge of −3.2 × 10⁻¹⁸ coulombs is 20 extra electrons when you use the classroom value of 1.6 × 10⁻¹⁹ coulombs. Enter the total charge and the elementary charge to get the electron count, with its sign. 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

Charge: -0
Elementary charge: 0

You get

Electron count: -20

Net electric charge on an everyday object is never a continuous fluid: it is a whole number of elementary charges, almost always extra electrons sitting on the surface or electrons that have been stripped away. This excess electrons calculator takes the object's total charge Q in coulombs and the elementary charge e in coulombs and returns the electron count n = Q / e. Students, electrostatics labs, science explainers, and automation scripts all need the same closed-form quotient so homework, articles, and pipelines never disagree on how many electrons that stated coulomb figure represents. Zero charge yields a count of zero.

What n = Q / e means and how the sign of the count is read

Macroscopic charge is quantized in units of the elementary charge. Every electron carries the same charge magnitude, fixed in SI since the 2019 redefinition at exactly 1.602176634 times ten to the minus nineteen coulombs, and a laboratory sample that reports minus 3.2 times ten to the minus eighteen coulombs is simply twenty of those units away from neutrality if you use the rounded classroom value 1.6 times ten to the minus nineteen.

The identity n equals Q divided by e is the entire calculation: there is no geometry, no Coulomb constant, no surface-area correction, and no mobility model. What changes from textbook to textbook is only the rounding of e, which is why this capability takes the elementary charge as an input instead of baking in a single constant. Pass the exact SI value when you want a metrological count; pass 1.6e-19 when you are matching a high-school worksheet that still prints that rounded figure.

The quotient is signed. With a positive e, a negatively charged object yields a negative electron count, which you read as excess electrons sitting on the body; a positively charged object yields a positive count, which you read as a deficit of electrons. If you instead pass the electron's own signed charge, a negative e, the same negative object charge yields a positive count of extra electrons.

Either convention is consistent as long as Q and e share a coherent sign convention on a given call. The engine does not convert microcoulombs, nanocoulombs, or picocoulombs: keep both inputs in SI coulombs so n is a pure electron count.

What you can do with it

Classroom electrostatics homework

Let students submit a net charge in coulombs and the elementary charge from their textbook, then verify n = Q/e against the worksheet, including a clear error when charge is not finite.

Lab notebooks for charged samples

Convert a measured coulomb figure from a Faraday cup, electrometer, or Van de Graaff demo into an electron count without mixing SI prefixes by hand.

Exam generators and LMS auto-grading

Mark excess-electron items with a deterministic oracle that rejects non-finite charge and never invents a count from a zero elementary charge.

FAQ

What happens if total charge is not a finite number?

Charge must be a finite number; NaN and plus or minus Infinity are rejected and are not billed. Missing charge is rejected the same way.

Which value of the elementary charge should I use?

Use 1.602176634e-19 C for the exact SI 2019 constant, or 1.6e-19 C to match a rounded classroom worksheet. A signed electron charge (negative e) is accepted; keep Q and e on a coherent sign convention.

Why can the electron count be negative?

With a positive e, n = Q/e is negative when the object is negatively charged, which you read as excess electrons. Pass a negative e (the electron's own charge) if you want a positive count for a negative Q.

How do I enter a charge given in microcoulombs or nanocoulombs?

Convert it to coulombs first, for example by multiplying microcoulombs by 10⁻⁶. The calculator never converts prefixes, so both charges must be in coulombs for the result to be a plain electron count.

What if I enter the electron's charge as a negative number?

That is accepted. With a negative elementary charge, a negatively charged object gives a positive count, read directly as extra electrons. Either sign convention works, as long as both charges follow the same one.

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/phys/excess-electrons

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/phys/excess-electrons \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"charge":-3.2e-18,"elementary_charge":1.6e-19}'

const res = await fetch("https://api.kit.forhosting.com/phys/excess-electrons", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "charge": -3.2e-18,
    "elementary_charge": 1.6e-19
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/phys/excess-electrons",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "charge": -3.2e-18,
    "elementary_charge": 1.6e-19
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/phys/excess-electrons", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"charge":-3.2e-18,"elementary_charge":1.6e-19}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"charge":-3.2e-18,"elementary_charge":1.6e-19}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/phys/excess-electrons", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "charge": -3.2e-18,
  "elementary_charge": 1.6e-19
}

Example response

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

Total charge that is not a finite number is rejected as invalid_input; a vanishing elementary charge is rejected the same way because the quotient would be undefined. Successful API calls cost $0.002; failed validation is not billed.

Input contract, units, and what happens when charge is not finite

Elementary charge must also be non-zero, because n = Q / e is undefined when the divisor vanishes; a zero e is rejected rather than returned as an infinite count. Keep units SI. If a problem states charge in microcoulombs, multiply by 1e-6 before calling; the engine never converts prefixes. Extremely large quotients that overflow to Infinity are rejected rather than returned as a non-finite electron count. POST a JSON body with two required fields. Field charge is the object's net electric charge Q in coulombs; aliases Q, total_charge, and q are accepted so lab notebooks and worksheet exports map without renaming the key. Field elementary_charge is the divisor e in coulombs; aliases e and e_charge are accepted. Each value may arrive as a JSON number or as a numeric string such as -3.2e-18 or 1.602176634e-19. Missing fields, empty strings, and any token that is not a finite number fail with invalid_input naming the field and are not billed. That includes NaN and plus or minus Infinity: the stated contract is that total charge must be finite, and the same finite-number rule applies to e. Zero charge is allowed and returns electron_count equal to zero, the consistent limit of a neutral object. On success the body echoes charge and elementary_charge, returns electron_count as the IEEE quotient rounded to twelve decimal places for stable goldens, and includes formula n = Q / e, method charge_over_elementary, and a units object that marks both inputs as C and the count as a dimensionless 1.

Where an excess electrons calculator earns its keep, and what it costs

Classrooms and tutoring platforms use an excess electrons calculator so learners can check how many extra electrons sit on a pith ball, a Van de Graaff dome, or a stated millicoulomb sample without dropping a digit in e or mixing up microcoulombs with coulombs. Exam generators and LMS plugins need a deterministic oracle that rejects a non-finite total charge instead of silently returning NaN that a buggy grader might treat as success. Electrostatics lab notebooks that log a measured coulomb figure and want the corresponding electron count call a tiny parse step instead of pulling a computer-algebra system for a one-line quotient. Failed validation does not consume balance. Use the on-page tool for a single charge at the desk; use the API when a grader, CMS plugin, or data pipeline needs the same contract under KIT balance. Do not send a current, a Faraday electrolysis mass, or a drift-velocity problem and expect this endpoint to answer those; they are different search intents served by other tools. Pin the returned electron_count in tests, keep requests small, and you get reproducible electron counts for homework, explainers, and edge workers without standing up symbolic math infrastructure of your own.

Technical questions

How do I calculate the number of excess electrons from charge?

Send a finite total charge Q in coulombs as charge (aliases Q, total_charge, q) and a non-zero finite elementary charge e as elementary_charge (aliases e, e_charge). The API returns the electron count n = Q / e.

What does the excess electrons 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