Urimalsaem phoneme search API

Urimalsaem phoneme search looks through the Urimalsaem dictionary (the NIKL Open Korean Dictionary) using conditions on the initial consonant, medial vowel, and final consonant (jamo) of each syllable. You can find entries with conditions that a single composed character cannot express, such as "verbs with the final consonant ㅎ," "one-syllable stems whose vowel is ㅚ and which have no final consonant," or "words ending in -아지."

Available on servers that include the spell checker

The Urimalsaem dictionary is loaded only on servers that include the spell checker (the correction feature). You can use it right away on the cloud (api.bareun.ai); a self-installed build must be a distribution that includes correction.

What can you find

What you want to find	Pattern	Position	Example results
Words ending in '-아지'	`아지`	Suffix match	송아지, 망아지, 강아지
Words ending in '-둥이'	`둥이`	Suffix match	막둥이, 쌍둥이, 귀염둥이
Stem with initial ㅅ and final ㄴ + 다	`{ㅅ//ㄴ}다`	Whole match	신다
Stem with vowel ㅚ and no final consonant + 다	`{/ㅚ/-}다`	Whole match	괴다, 되다, 쇠다, 외다, 쬐다
Predicates whose stem has a final ㅎ	`*{//ㅎ}다`	Whole match	낳다, 넣다, 놓다, 내놓다
Predicates whose stem has a final ㄷ (ㄷ-irregular candidates)	`*{//ㄷ}다`	Whole match	걷다, 듣다, 묻다, 싣다

How to write patterns

A pattern is a sequence of syllable-level tokens.

Token	Meaning
A character such as `다`	That character as is
`{initial/medial/final}`	A jamo condition on one syllable. Positions are separated by `/`
`*`	Zero or more of any syllable
`?`	Exactly one of any syllable

Each position in {initial/medial/final} is written as follows.

Notation	Meaning
Empty or `.`	Anything
`ㅅ`	That jamo
`ㄹㄱ`	A double final consonant, diphthong, or tense consonant written as two jamo (ㄹㄱ→ㄺ, ㅗㅏ→ㅘ, ㄱㄱ→ㄲ). You may also enter it as a single character such as ㄺ
`ㄱ\|ㅋ`	One of several
`[ㄱㄴㄷ]`	One of several (bracket notation). Exclusion such as `[^ㄱㄴ]` and ranges such as `[ㄱ-ㄷ]` also work
`-`	(final position) No final consonant
`+`	(final position) Any final consonant is enough

You can omit positions from the end. {ㅅ/ㅏ} means "initial ㅅ, medial ㅏ, any final consonant," and {ㅅ} means "initial ㅅ only."

Do not build jamo regular expressions yourself

The ㅅ you type on the keyboard and the initial or final ㅅ inside a decomposed character are different characters, so if you build the regular expression by hand, you silently get 0 results without any error. Just write the pattern and the server does the conversion. You can check the regular expression the server actually used in the regex field of the response. For jamo that cannot be typed as a single character on the keyboard, such as the double final ㄺ or the diphthong ㅘ, write them as ㄹㄱ or ㅗㅏ. For example, words ending in the double final ㄺ are *{//ㄹㄱ} (닭, 흙).

How to call it

Call bareun.DictSearchService/SearchDict. Over REST (HTTP+JSON), it looks like this.

curl -s -X POST https://api.bareun.ai/bareun.DictSearchService/SearchDict \
  -H "api-key: <API-KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "pattern": "아지",
    "anchor": "DICT_SEARCH_ANCHOR_SUFFIX",
    "pos": ["명사"],
    "std_only": true,
    "with_definition": true,
    "limit": 20
  }'

{
  "entries": [
    {
      "word": "강아지",
      "pos": "명사",
      "senseCount": 5,
      "senses": [
        { "senseNo": 1, "definition": "개의 새끼.", "targetCode": 3402 }
      ]
    }
  ],
  "totalMatched": 25,
  "totalSenses": 60,
  "regex": "아지$ (jamo-level regular expression the server actually used)",
  "elapsedMs": "346",
  "scanned": 1136046
}

Request fields

Field	Meaning	Default
`pattern`	Jamo pattern (required)	—
`anchor`	Pattern position: `DICT_SEARCH_ANCHOR_WORD` (whole), `_PREFIX` (start), `_SUFFIX` (end), `_CONTAINS` (contains)	Whole match
`pos`	POS filter. A dictionary label such as `동사` (verb) or `명사` (noun), or a group name such as `용언` (predicate) or `체언` (substantive). With several, matching any one passes	All
`std_only`	If `true`, excludes non-standard words, dialect words, and North Korean words	`false`
`with_definition`	If `true`, includes definitions and usage examples	`false`
`limit` / `offset`	Maximum number of entries (default 100, maximum 1000) / number to skip	100 / 0
`count_only`	If `true`, returns only the count without entries	`false`

POS group names: 용언 (verbs, adjectives, auxiliary predicates), 동사류 (verb group), 형용사류 (adjective group), 체언 (nouns, pronouns, numerals), 부사류 (adverb group), 수식언 (modifiers), 관계언 (relational words).

Response fields

Field	Meaning
`entries`	List of matching entries. Definitions are grouped into one when the headword and POS are the same
`entries[].word` / `pos` / `conju`	Headword, POS, conjugation form
`entries[].senses`	List of definitions (when `with_definition=true`): superscript number, definition, category, Urimalsaem number, usage examples
`entries[].isDialect` / `isNorthKorean` / `isNonStd` / `stdWord`	Whether the entry is a dialect word, North Korean word, or non-standard spelling, and the standard word
`totalMatched` / `totalSenses`	Number of matching entries / number of definitions (the totals, regardless of `limit`)
`regex`	The regular expression the server actually used (to check how the pattern was interpreted)
`scanned` / `elapsedMs`	Number of dictionary entries scanned / time taken (milliseconds)

Check the count first for broad patterns

This search scans the whole of Urimalsaem (about 1.13 million entries) without an index. One search takes several hundred milliseconds, so for a broad pattern when you do not know how long it will take, it is best to check the scale first with count_only.

Try it on the web

To try patterns without code, use the bareun.ai Urimalsaem phoneme search page. Clicking an example pattern fills it in right away, and you can toggle the POS and standard-word filters and the display of definitions. The built-in web screen of a self-installed server has the same tab (in distributions that include correction).

From an AI agent, you can use the same search with the search_dict tool of the Bareun MCP server; see Using the MCP server. What this search is used for (Korean-language research, naming, word games, language data, and what AI agents can newly do with this tool) is organized by use case in Putting phoneme search to use.

Frequently asked questions

Q. How is phoneme (jamo) search different from regular dictionary search?

A. Regular search finds only by composed characters (e.g. "신"). Phoneme search lets you put conditions on the initial, medial, and final of each syllable, so you can find Korean words by conditions a single character cannot express, such as "verbs with the final consonant ㅎ" or "one-syllable stems whose vowel is ㅚ."

Q. Which dictionary does it search?

A. The National Institute of Korean Language's Urimalsaem (about 1.13 million entries). It also contains dialect words, North Korean words, and non-standard spellings, so by default it shows everything, and turning on std_only leaves only standard words.

Q. The search seems slow. Is that normal?

A. It scans the whole dictionary without an index, so one search takes several hundred milliseconds. It is a feature suited to research and lookup rather than bulk automated calls, and for broad patterns, check the scale first with count_only.

Q. Can I search like an initial-consonant game, with "ㄱㅅ"?

A. Yes. Put an initial-consonant condition on each syllable, like {ㄱ}{ㅅ}. For example, a whole match for {ㄱ}{ㅅ} finds two-syllable words with initials ㄱ and ㅅ (가수, 강산, etc.).