Ordinal gematria calculator
Add up a word with ordinal gematria, where every letter counts as its place in the alphabet: KIT is 11 + 9 + 20, a total of 40, which reduces to the single digit 4. Spaces and digits are skipped and listed. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- KIT
- Total
- 40
- System
- ordinal_gematria_A1
- Reduced
- 4
- Letter count
- 3
Ordinal gematria is the simplest Latin letter-value system: each letter counts as its place in the alphabet, so A is one, B is two, C is three, and Z is twenty-six. Writers, puzzle designers, numerology hobbyists, and teachers use it to turn a name or short phrase into an integer total they can compare across words, then often reduce that total to a single digit by adding digits until only one remains. This ordinal gematria calculator accepts any string, scores only A–Z letters without caring about case, returns both the raw total and the digital-root reduced value, and reports every non-alphabetic character that was ignored so you never wonder why a space, hyphen, or digit disappeared from the sum. No network calls, no randomness, and no model tokens—just a transparent mapping you can recompute by hand on paper.
How ordinal gematria assigns values, totals, and reduction
Ordinal gematria maps the twenty-six Latin letters to their natural alphabet positions. Position one is A and contributes one; position two is B and contributes two; position three is C and contributes three; the pattern continues until Z, the twenty-sixth letter, which contributes twenty-six. There is no multiplier: the value of a letter is simply its one-based index in A–Z.
To score a word you convert every letter to that value and add the results into a single integer total. Case does not matter: lowercase a is treated as A, so “Kit”, “KIT”, and “kit” all produce the same total and the same reduced digit. After the sum is known, this calculator also reduces the total by digital root—repeatedly adding the decimal digits until a single digit from one through nine remains.
That reduced field is the standard single-digit form used in many hobby numerology tables when people ask for the “final number” of a name.
Where ordinal gematria is useful
Educators use the tool to show students how a transparent cipher maps letters to numbers and how digital-root reduction collapses a large total into a single digit without opaque software. Game and puzzle authors batch-score word lists to balance difficulty or to seed riddle answers that share a target total or the same reduced digit. Name-meaning blogs and personal branding tools convert brand candidates into comparable integers under a fixed published rule that differs from English gematria’s six-step scale, so the SEO intent stays distinct.
Failed validation does not consume balance. Keep requests short, pin the breakdown order in tests, and you get reproducible ordinal gematria totals for homework, landing-page demos, and edge workers without standing up a custom numerology service of your own.
What you can do with it
Puzzle and game word scoring
Batch-score word lists so riddles, crossword themes, or game levels share a target ordinal total or the same reduced digit.
FAQ
How does ordinal gematria value each letter?
Case is ignored. The total is the sum of those values; reduced is the digital root of the total.
What is the reduced value?
Reduced is the digital root: add the digits of total repeatedly until a single digit from 1 to 9 remains. Example: KIT totals 40, which reduces to 4.
What if my string has no English letters?
Ordinal gematria requires at least one A–Z letter; empty or symbol-only input is not billed.
What happens to spaces, digits and hyphens in ordinal gematria?
They add nothing to the total or to the reduced digit. Every character that is not a letter from A to Z is skipped and shown in a separate list, so you can check what was left out.
How is ordinal gematria different from English gematria?
Ordinal gematria uses each letter's plain position, so A is 1 and Z is 26. English gematria multiplies that position by six, so the same word gets a total six times larger under that rule.
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
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-ordinal \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"KIT"}'const res = await fetch("https://api.kit.forhosting.com/enc/gematria-ordinal", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "KIT"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/gematria-ordinal",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "KIT"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/gematria-ordinal", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"KIT"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"KIT"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/gematria-ordinal", 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": "KIT"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.gematria_ordinal",
"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
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
How ordinal gematria assigns values, totals, and reduction
Digits, punctuation, spaces, and symbols contribute nothing to the sum; they are listed under non_alphabetic so you can audit what was skipped. Empty input and strings that contain no English letters at all are rejected with invalid_input rather than returning a silent zero, because a zero total without letters is almost always a client mistake. The response always includes the original text, a system label that names the A=1 ordinal scheme, the integer total, the reduced single digit, letter_count, a breakdown array of each scored letter with its value, the non_alphabetic list, its count, and a boolean has_non_alphabetic flag for quick checks in scripts and tests.
Input contract, response fields, and error behaviour
The free browser form uses the same field. Length is capped at ten thousand characters to keep requests small and predictable. POST a JSON body with a required string field named text (aliases word, phrase, input, q, and value are accepted). On success you receive text echoed back, system set to ordinal_gematria_A1, total as a positive integer sum of letter values, reduced as the digital root of that total (a single digit from one to nine for any positive total), letter_count, breakdown as an ordered list of objects each with letter in uppercase and value equal to alphabet position, non_alphabetic as an array of the exact ignored characters in order of appearance, non_alphabetic_count, and has_non_alphabetic. Example: the three-letter string KIT maps K to eleven, I to nine, and T to twenty, so total is forty, reduced is four (four plus zero), letter_count is three, and non_alphabetic is empty. A phrase like “A-1” scores only A as one, reports hyphen and digit one as non-alphabetic, sets has_non_alphabetic true, and reduces total one to reduced one. Missing text, empty string, payloads longer than the limit, and strings with no A–Z letters fail with invalid_input and are not billed. Pair the API with your own UI if you want charts of letter contributions; this endpoint only computes the total, the reduced digit, and the audit fields.
Where an ordinal gematria API earns its keep
Developers embed the endpoint in scripts that normalize case, inspect skipped punctuation, and store both total and reduced next to source strings for search, clustering, or quiz keys. Because every successful call is pure computation, the published base price stays at $0.002 with no model tokens.
Integration use cases
Classroom demos of ordinal letter values
Show students how A=1 through Z=26 builds a word total, then reduce by digital root and compare hand work against the API breakdown.
Brand and name comparison tools
Score candidate brand names under the ordinal A=1 rule, store total and reduced beside each string, and sort or cluster by either field.
Technical questions
What happens to spaces, digits, and punctuation?
They are not added into the total. The API lists them in non_alphabetic and sets has_non_alphabetic true so you can audit skipped characters.
What does the ordinal 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.