Korean spell check API comparison: which ones can you call from code?
Short answer: The only commercial APIs for Korean spelling and grammar correction that you can call reliably from a program are, in practice, Bareun and
the Pusan National University checker (Bareun Hangul). Naver's spell checker has no public API. Open-source libraries
are either spelling-dictionary based (Hunspell) or wrappers that call a web checker unofficially, so they are hard to put into a service as they are.
The quality and approach of the checkers themselves are compared in Spell checker comparison. This document focuses on integration (how you call it, stability, and operations).
Comparison at a glance
| Item | Bareun | Pusan National University checker (Bareun Hangul) | Naver spell checker | Hunspell family | Unofficial web wrappers |
|---|---|---|---|---|---|
| Public API | gRPC · REST · connect-web | XML-based API provided | None | Library calls | None (parses web responses) |
| Streaming | StreamCorrectError provided | None | — | — | — |
| Input limit per call | Send the whole document (2,000 characters without login; per-plan limit after login) | 300 eojeol per call | 500 characters per call | No limit | Follows the web checker's limit |
| Correction evidence | Category, reason, rule source, example usages | Explanations provided | Brief help text | None | None |
| Korean grammar and word spacing | Handled with morphological analysis | Handled with rules and grammar | Handled | Mostly spelling; weak on word spacing | Depends on the web checker's results |
| Closed-network install | Possible (separate contract) | Has delivery track record | Not possible | Possible | Not possible |
| Stability | Service-level guarantee | Service provided | Not disclosed | Stable, as it is a library | Breaks when the web page changes |
| AI agents (MCP) | Provided as a tool | None | None | None | None |
Competitors' input limits and scope of service are based on values each service has published or announced, and may change with their policies.
Do not put unofficial wrappers in a service
Libraries that imitate a web checker over HTTP, because it has no public API, have been widely used. This approach breaks as soon as the target site's pages or responses change, can get blocked when traffic grows, and may violate the terms of use. Trying one out as a pilot is different from building it into a service.
Three ways to call
Bareun lets you call the same correction engine in three ways. The response structure is the same whichever you use.
from bareunpy import Corrector
corrector = Corrector(apikey="YOUR_ISSUED_API_KEY", host="api.bareun.ai", port=443)
res = corrector.correct_error("아버지가방에들어가신다")
print(res.revised)
curl -X POST https://api.bareun.ai/bareun.RevisionService/CorrectError \
-H "Content-Type: application/json" \
-H "api-key: YOUR_ISSUED_API_KEY" \
-d '{"document": {"content": "아버지가방에들어가신다"}}'
const res = await client.correctError({
document: { content: "아버지가방에들어가신다" },
});
console.log(res.revised);
For details on how to call, see Spell check API, REST API, and Using it on the web.
What actually causes trouble when you integrate
1. Input limits: who splits the text?
Naver's checker states a limit of 500 characters per call, and the Pusan National University checker 300 eojeol (space-delimited word units) per call. One cover letter or one page of a report exceeds these limits, so the calling side has to write code that splits the text, sends it in several calls, and stitches the results back together. You also have to accept that judgments on conjugated forms and particle attachment get shaky at the cut boundaries.
Bareun takes the whole document and returns it as a paragraph (contentsList) → sentence (sentencesList) structure while keeping the original offsets (beginOffset).
You can map correction results straight back to positions in the original text.
2. When you have to explain results to users
If you hand users only the corrected text, they will ask why it was changed. For each item, Bareun returns the category (RevisionCategory),
the reason (comment), the rule source (rule_article), and example usages (examples), so you can show the evidence on screen as is.
3. When internal terms get flagged as typos
Product names, personal names, and technical terms become correction targets if they are not in the dictionary. In Bareun, a term registered in the custom dictionary
takes effect immediately without stopping the server (Custom dictionary API).
4. When you stream long documents to the screen
With StreamCorrectError, you receive correction results as a stream and can show each sentence on screen as soon as it is finished.
Related documents
- Spell checker comparison: comparison of each checker's approach and quality
- Spell check API · Using the spell checker
- On-premises Korean spell checker adoption guide: for installing directly on a closed network
Frequently asked questions
Q. Which Korean spell check API do you recommend?
If you need to call it reliably from a program, Bareun (gRPC, REST, connect-web, streaming) and the Pusan National University checker (XML-based API) are
the realistic choices. Naver's spell checker has no public API. If you want to show correction evidence on screen or
update a custom dictionary often, Bareun is the better fit.
Q. Can I use Naver's spell checker as an API?
It has no public API. Unofficial libraries exist that parse its web responses, but they break when the target site changes, can be blocked when traffic grows, and may violate the terms of use, so we do not recommend them for services.
Q. Is there a free open-source Korean spell check library?
You can use a Hunspell-family spell checker for Korean, but it only checks whether a word is in the dictionary, so it has trouble catching Korean grammar errors such as particle attachment, conjugation, and word spacing. To cover grammar as well, you need a checker based on morphological analysis.
Q. Can long text be corrected in a single call?
Bareun takes the whole document and returns it with the paragraph and sentence structure and original positions preserved. Without logging in, you can try up to 2,000 characters,
and after logging in it checks up to your plan's limit in one go. Naver states 500 characters per call and the Pusan National University checker
300 eojeol per call, so the calling side has to split the text before sending it.
Q. Do the results explain why something was changed?
For each item, Bareun returns the category, the reason (comment), the rule source (rule_article), and example usages (examples).
You can show the evidence to users as is.