ForHosting KIT · Developer Utilities

Anagram solver against a dictionary

This anagram solver checks a supplied word dictionary against the letters you have and returns every word that can be formed without using any letter more times than it appears.

● BetaFree · in your browser
Use it from WebAPIEmailTelegramApp soon

Matching is case-insensitive, whitespace in the letter set is ignored, and shorter words are welcome because the solver uses any subset of the available letters. Results are deduplicated and ordered consistently, making the tool useful for word games, vocabulary exercises, puzzle construction, and repeatable application workflows.

Provide letters and a dictionary that fit your puzzle

Start with the complete rack, hand, or pool of letters available in the puzzle. Repeated letters matter: the letters in “letter” permit two uses of “t” and two uses of “e,” while a candidate requiring a third copy will not match. Spaces, tabs, and line breaks in the letter field are ignored, so you may paste a visually grouped set without changing the calculation. Then provide the candidate dictionary as a list of words. The solver does not consult an external word list or guess which vocabulary your game accepts; your dictionary is the authority. That makes the result appropriate for games with house rules, classroom lists, specialist terminology, or a competition’s approved lexicon. Each nonempty dictionary entry is tested independently. A candidate may use every supplied letter or only a subset, so a five-letter rack can produce both five-letter anagrams and shorter valid words. Empty dictionary entries are skipped rather than returned as words. Keep punctuation only when it is genuinely part of both the candidate and available character set, because it is treated as a usable character rather than silently removed.

Understand matching, duplicates, and result order

Matching is case-insensitive and uses normalized text, which means “React” can match letters entered as “TRACE.” The algorithm builds a frequency table for the available characters and then checks each candidate against a fresh copy of those counts. As soon as a word asks for a character that is absent or already exhausted, that word is rejected. This frequency-based approach is important for repeated letters: simply checking whether every distinct character appears would incorrectly accept words that need too many copies. Equivalent dictionary entries that differ only by capitalization or surrounding whitespace are returned once, preserving the spelling of the first accepted entry. The output places longer words first, which is convenient in games where longer plays are normally more valuable, and orders words of equal length alphabetically for stable results. It returns both the ordered words array and a count, so software can display the matches directly and also summarize the result without recounting it. No random choice, network lookup, or changing external dictionary can alter a repeated calculation with identical input.

Use the solver reliably in games and automated workflows

For an interactive puzzle, paste the current letters, supply the relevant dictionary, and scan the longest results first. For automated use, send the same two fields and consume the returned words and count. Because the capability evaluates only the dictionary you provide, you can keep separate lists for different languages, age groups, tournament editions, or product vocabularies without changing the algorithm. It is also useful for puzzle authors: begin with a proposed letter pool, run a curated answer list through the solver, and confirm which intended and unintended solutions are possible. The calculation is deterministic, so generated puzzle checks can be placed in tests and compared over time. Input limits keep browser and API execution predictable: the letter pool accepts up to 256 non-whitespace characters, the dictionary accepts up to 10,000 entries, and each candidate accepts up to 128 non-whitespace characters. If the letter set is empty, missing, or contains only whitespace, the request fails instead of returning a misleading empty result. Invalid dictionary shapes or non-string entries likewise produce a clear input error, helping calling applications distinguish bad data from a legitimate puzzle with zero matches.

Find playable word-game moves

Check a rack against the exact tournament or house dictionary and review the longest available words first.

Build vocabulary exercises

Use a class-specific word list to generate all valid answers for a supplied group of letters.

Validate anagram puzzles

Confirm intended solutions and uncover shorter accidental answers before publishing a puzzle.

Does a word have to use every supplied letter?

No. A match may use any nonempty subset of the letters, but it cannot use a character more often than supplied.

Does capitalization affect matching?

No. Matching is case-insensitive, while the first accepted spelling from the dictionary is preserved in the output.

Is a built-in dictionary used?

No. The dictionary in your request is the complete authority, so results follow the vocabulary and rules you choose.

How are duplicate dictionary entries handled?

Equivalent entries are returned once. The spelling of the first accepted entry is kept.

How are results ordered?

Longer words appear first, followed by alphabetical ordering among words of equal length.

What does it cost?

Each API request costs $0.002, and the same deterministic solver can run in the browser.

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.

POSThttps://api.kit.forhosting.com/game/anagram-solver-dictionary

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.

curl -X POST https://api.kit.forhosting.com/game/anagram-solver-dictionary \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"letters":"Trace","dictionary":["trace","crate","react","cat","tree","ace","race"]}'
{
  "letters": "Trace",
  "dictionary": [
    "trace",
    "crate",
    "react",
    "cat",
    "tree",
    "ace",
    "race"
  ]
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "game.anagram_solver_dictionary",
  "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.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

max_letters256
max_items10000
max_word_length128
HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

Read the full KIT documentation →