ForHosting KIT · Developer Utilities

Hebrew gematria calculator

Type a Hebrew word and get its gematria in the standard system: שלום scores 300 + 30 + 6 + 40, a total of 376, with each letter's value listed in reading order. Final letters keep their ordinary values. 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

Text: שלום

You get

Total: 376
Letter count: 4
System: mispar_hechrachi

Hebrew gematria assigns every letter of the alef-bet a fixed integer and treats a word as the sum of those values. Students of Hebrew, biblical literature, and Jewish numerology look up the standard system known as mispar hechrachi when they need a reproducible total for a name, a verse fragment, or a classroom exercise. This Hebrew gematria calculator accepts a Hebrew string, maps each letter from alef through tav—including the five final forms—onto the classical table, and returns both the grand total and an ordered per-letter breakdown you can show beside the source text. Spaces and common Hebrew punctuation are ignored so multi-word phrases still score cleanly.

How standard Hebrew gematria assigns letter values

In the absolute or ordinal system called mispar hechrachi, each Hebrew letter carries a single fixed value that never changes with context. Alef is one, bet two, gimel three, through tet for nine. Tens run from yod at ten through tsadi at ninety; hundreds are qof one hundred, resh two hundred, shin three hundred, and tav four hundred.

The five final forms that appear at the end of a word—final kaf, final mem, final nun, final pe, and final tsadi—use the same values as their medial counterparts in this standard table, so a word that ends in final mem still contributes forty, not a special hundreds-range total used only in some extended systems. Adding every letter produces the gematria of the string. For example, the common greeting written shin-lamed-vav-final-mem scores three hundred plus thirty plus six plus forty, for a total of three hundred seventy-six.

Because the mapping is a pure lookup table, two clients that send the same Unicode letters always receive the same total and the same ordered list of letter objects. That stability is what turns gematria from a hand calculation into a contract you can pin in tests, gradebooks, and content pipelines without worrying about floating-point noise or locale-dependent collation.

What you can do with it

Classroom and homework checks

Let students submit a Hebrew word and verify both the total and the per-letter table against textbook mispar hechrachi values.

Automation and content indexes

Score Hebrew strings in scripts or CMS plugins without maintaining a local letter-value spreadsheet.

FAQ

How does the Hebrew gematria calculator work?

Send a Hebrew string in the text field. Each letter א–ת is mapped to its standard mispar hechrachi value and the values are summed. The response includes total and a letters array with each character, value, and position.

What values do final letters (sofit) use?

In this standard system, final kaf, mem, nun, pe, and tsadi use the same values as their non-final forms (20, 40, 50, 80, 90). Extended hundreds-range systems are not applied here.

What happens with non-Hebrew characters?

Latin letters, digits, and other non-Hebrew glyphs are not scored; the error message names the first offending character so clients can fix the input.

Are spaces and punctuation allowed?

Yes. Spaces, common Hebrew marks (geresh, gershayim, maqaf), and ordinary separators are ignored. At least one Hebrew letter must remain after skipping those characters.

What value does each Hebrew letter have?

Alef to tet count 1 to 9, yod to tsadi count the tens from 10 to 90, and qof, resh, shin and tav are 100, 200, 300 and 400. These values never change with context in the standard system.

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/enc/gematria-hebrew

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/enc/gematria-hebrew \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"שלום"}'

const res = await fetch("https://api.kit.forhosting.com/enc/gematria-hebrew", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "text": "שלום"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/enc/gematria-hebrew",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "text": "שלום"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/gematria-hebrew", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"text":"שלום"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"text":"שלום"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/gematria-hebrew", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "text": "שלום"
}

Example response

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

Latin letters, digits, and other non-Hebrew characters fail with invalid_input instead of a silent partial sum, which keeps automated checks honest.

Input contract, response shape, and non-Hebrew errors

The string must contain at least one Hebrew letter in the range alef through tav. Whitespace, maqaf, geresh, gershayim, and ordinary Latin punctuation used as separators are skipped and do not contribute to the sum. An empty string or a string that becomes empty after stripping separators also fails, so clients never see a zero total that looks successful. Any other character—Latin A–Z, Arabic digits, emoji, or unsupported symbols—raises invalid_input with a message that names the offending character and states that only Hebrew letters are scored. On success the body echoes the original text, reports total as a non-negative integer, letter_count as the number of valued glyphs, and letters as an array of objects each holding letter, value, and one-based position in reading order among valued letters only. Two diagnostic strings method and system identify the algorithm as standard_gematria under mispar_hechrachi so callers can log which table was used.

Where a gematria API earns its keep

Language classrooms and cheder-style lessons use a Hebrew gematria calculator so learners can check name totals and verse fragments without flipping a paper chart for every letter. Content sites that rank for searches such as hebrew gematria calculator need a live tool whose free browser path matches the automation path byte-for-byte on the same pure module. Exam generators and LMS plugins need a deterministic oracle that rejects Latin transliteration as invalid_input instead of inventing a partial sum from mixed scripts. Research notes and hobby projects that compare word pairs or build indexes of equal-value terms can call the endpoint in bulk without standing up a spreadsheet of twenty-two rows.

Integration use cases

Teaching demos and live widgets

Show a free browser calculator that matches the API golden fixtures so lectures and homework never disagree on a total.

Technical questions

What does the Hebrew gematria 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