ForHosting KIT · Science

Atomic mass calculator

Turn isotope data into a table atomic mass: chlorine, with 0.7577 of its atoms at 34.96885 amu and 0.2423 at 36.9659 amu, comes to 35.452735215 amu. You see each isotope's contribution, and abundances that do not add up to one are refused. 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

The atomic mass printed on the periodic table is not the mass of one chosen atom. It is a weighted average of the masses of the naturally occurring isotopes of that element, each scaled by its fractional abundance in nature. This calculator takes a list of isotope masses in atomic mass units and matching fractional abundances, multiplies each pair, and returns the atomic mass in amu together with per-isotope contributions so you can see how much every nuclide pulls the mean.

What atomic mass means and how isotope masses and abundances combine

Every chemical element with more than one stable isotope has a table atomic mass that is a population average, not the mass of a single nuclide. Chlorine is the usual classroom picture: most atoms are chlorine-thirty-five, a smaller share are chlorine-thirty-seven, and the number under Cl on the table sits between those two masses, closer to the more common one. The definition is a weighted mean in atomic mass units.

Write each isotope mass in amu, write each natural abundance as a fraction between zero and one, multiply mass by fraction for every isotope, and add the products. Two isotopes give m1 times f1 plus m2 times f2; three or more isotopes continue the same sum with no extra terms and no lookup table. Fractional abundance is not a percent: seventy-five point seven seven percent of chlorine is chlorine-thirty-five, so the matching fraction is zero point seven five seven seven, never seventy-five.

The fractions must add to one because they describe a complete sample of atoms. If they add to anything else you have omitted an isotope, mixed percent with fractions, or mistyped a value, and the resulting number would not be the atomic mass chemists report. This tool applies that definition exactly.

It does not guess missing nuclides, it does not convert percent for you, and it does not fetch a published table value from a symbol. Supply the isotope rows, require the abundances to sum to one, and read the atomic mass in amu with the contribution of each row shown beside the total.

Classroom, lab and practical limits

Students and tutors use an atomic mass calculator to check chlorine, copper, boron, and magnesium homework without flipping a percent into a fraction the wrong way. Exam generators and learning platforms need a deterministic oracle that rejects incomplete abundance lists instead of silently returning a number a buggy grader might mark correct. Laboratory notebooks that ingest isotope mass-spectrometry tables can validate that reported fractions still sum to one and then store the weighted atomic mass next to the raw rows.

Call the in-browser tool for lecture demos and quick verification. Keep abundance lists fractional and complete. If your source data is in percent, divide each entry by one hundred before calling.

Authors shipping SDKs can map the contributions array into a table with mass, fraction, and contribution columns—the same columns students fill when they compute atomic mass by hand.

What you can do with it

Homework and exam checks

Students submit isotope masses and fractional abundances, compare the weighted atomic mass in amu and per-isotope contributions to worked solutions, and get a clear error when abundances do not sum to one.

Lab and data pipelines

Scripts that ingest isotope tables validate that fractional abundances sum to one and compute table-style atomic mass in amu without reimplementing the weighted sum in every language.

FAQ

How do I calculate atomic mass from isotope masses and abundances?

Send isotopes as rows of mass (amu) and abundance (fraction in [0, 1]).

What happens if abundances do not sum to one?

Incomplete isotope lists and percent values that still look like numbers would produce a wrong table mass, so they are rejected and not billed.

Should I enter percent abundances or fractions?

Fractions only, each between zero and one, summing to one. Convert 75.77% to 0.7577 before calling. Values greater than one are rejected as not percent-aware input.

What unit is the atomic mass reported in?

Atomic mass units (amu), also called daltons. The unit field is the string amu so clients can label the number without guessing u versus g/mol.

Why is chlorine's atomic mass between 35 and 37?

Because the table value is an average weighted by abundance. Most chlorine atoms are chlorine-35 and a smaller share are chlorine-37, so the result sits between the two masses, closer to the more common 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/chem/atomic-mass

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/chem/atomic-mass \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"isotopes":[{"mass":34.96885,"abundance":0.7577},{"mass":36.9659,"abundance":0.2423}]}'

const res = await fetch("https://api.kit.forhosting.com/chem/atomic-mass", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "isotopes": [
      {
        "mass": 34.96885,
        "abundance": 0.7577
      },
      {
        "mass": 36.9659,
        "abundance": 0.2423
      }
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/chem/atomic-mass",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "isotopes": [
        {
            "mass": 34.96885,
            "abundance": 0.7577
        },
        {
            "mass": 36.9659,
            "abundance": 0.2423
        }
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/chem/atomic-mass", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"isotopes":[{"mass":34.96885,"abundance":0.7577},{"mass":36.9659,"abundance":0.2423}]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"isotopes":[{"mass":34.96885,"abundance":0.7577},{"mass":36.9659,"abundance":0.2423}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/chem/atomic-mass", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "isotopes": [
    {
      "mass": 34.96885,
      "abundance": 0.7577
    },
    {
      "mass": 36.9659,
      "abundance": 0.2423
    }
  ]
}

Example response

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

Abundances must be fractions between zero and one and they must sum to one; percent figures and incomplete sets fail with invalid_input instead of a silently wrong table number. The same pure arithmetic runs free in your browser and as a prepaid API call at $0.002 per successful item, so homework checks and lab scripts never disagree on the weighted sum.

Input contract, response shape, and what happens when abundances fail to sum to one

Each row is an object with mass, a strictly positive finite number in amu, and abundance, a finite fraction in the closed interval from zero to one. After every row parses, the engine sums the abundances. If the sum is not one within a tiny floating-point tolerance of one part in a million, the task fails with a message that abundances must sum to one, instead of returning a scaled mean that would look like a table value and be wrong. The contributions array repeats mass and abundance for each isotope and adds contribution equal to their product, which is the amount that nuclide adds to the mean. Send a JSON object whose required field is isotopes: a non-empty array of rows, at most thirty-two entries. Aliases nuclides, list, and items are accepted for the array; isotope_mass and m are accepted for mass; fraction, fractional_abundance, and f are accepted for abundance. Missing arrays, empty lists, non-object rows, non-finite values, non-positive masses, and abundances outside zero to one fail with invalid_input naming the field, and those failures are not billed. On success the payload echoes the rounded isotope rows, isotope_count, and abundance_sum so you can confirm completeness. The primary result is atomic_mass in amu, with unit always the string amu. Summing the contribution values recovers atomic_mass within rounding, which is useful when a grader checks work step by step rather than only the final number. The formula field restates atomic_mass equals the sum of mass_i times abundance_i. Identical inputs always produce identical JSON because the path is pure arithmetic with no network, no random seed, and no wall clock.

Classroom drills, lab tables, API pricing, and practical limits

Use the API when a pipeline, LMS plugin, or curriculum generator needs a stable contract under KIT balance at $0.002 per successful item; validation failures never consume balance. Pair this endpoint with molar-mass helpers when the next step is a compound mass from averaged elemental values, or with stoichiometry calculators once the elemental averages are fixed.

Integration use cases

Tutoring and curriculum generators

Lesson builders produce chlorine, copper, and magnesium drills with structured JSON for flashcards, step sheets, and auto-graded atomic mass problems that reject percent-by-mistake inputs.

Technical questions

What does the atomic mass 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