Adding grammar checking to a product used to mean embedding someone else's UI — a branded widget with someone else's suggestion cards. Today you can keep your own interface and call a proofreading API that returns corrections your app renders however it wants.

This guide compares seven options developers actually evaluate: AmberPen, Sapling, GrammarBot Neural, LanguageTool, Harper, Trinka, and Grammarly's developer platform. A disclosure up front: we build AmberPen, and we benchmark it against competitors on public datasets with published methodology. Where another product wins, we say so.

What to evaluate before you commit

Six properties determine whether an API works in production:

  • Edit format. Some APIs return only corrected text. Others return structured edits — the exact range and replacement for every correction. Structured edits let you underline issues, show suggestions, and let users accept or reject individual changes.
  • Correction quality. Measured quality on public corpora beats marketing claims. Ask what a vendor publishes, then test with your own text.
  • Latency. For as-you-type checking, the median response time is the experience. Batch use cases can tolerate more.
  • Vocabulary control. Your product names and domain terms must not get "corrected." Look for per-request dictionaries or custom rules.
  • Privacy. Does the vendor train on your text? How long is it retained, and can you turn retention off? Is self-hosting an option?
  • Pricing model. Per-character, per-token, per-seat, and flat subscriptions behave very differently as usage grows.

At a glance

API Approach Structured edits Median latency Pricing model
AmberPen Neural Yes, UTF-16 offsets + explanations 217 ms Flat per character
Sapling Neural Yes 620 ms Per character, volume tiers
GrammarBot Neural Neural Yes 1,000 ms Usage-based
LanguageTool Rules + statistical Yes 287 ms Free tier, premium, self-hosted
Harper Rules, local Via library ~2 ms (in-process) Free, open source
Trinka Neural, academic focus Yes Not published Custom enterprise
Grammarly platform Neural No corrections — scores only Not published Enterprise

Latency figures for AmberPen, Sapling, GrammarBot Neural, and LanguageTool come from our benchmark runs over identical inputs in July 2026. Harper runs locally, so its number excludes any network round trip.

1. AmberPen

AmberPen is a neural proofreading API built around structured output. Every request returns sorted, non-overlapping edits with UTF-16 offsets that work directly with JavaScript's slice; the SDK's applyEdits reconstructs the corrected text from them. An optional second pass, evaluate mode, reviews every proposed edit, drops the unwarranted ones, and returns a plain-language explanation, a category, and every valid replacement ranked by relevance.

It is the only API here with incremental proofreading: pass a stable textId and the SDK diffs the document in your own process, sending only the chunks that changed, which cuts cost and latency on long documents. Streaming mode delivers complete edit batches as sections finish, and per-request custom dictionaries protect brand names and specialist vocabulary. AmberPen does not train on customer text, and does not retain submitted text once the response is returned — incremental proofreading runs client-side, so it adds no server-side retention.

Benchmarks. AmberPen leads the JFLEG fluency benchmark at 0.561 GLEU and leads CWEB recall at 65.5%, finding about two-thirds of the errors human annotators marked in web text. It is second on CWEB precision, behind GrammarBot Neural. At 217 ms median latency it is the fastest hosted neural API in this list — only rule-based LanguageTool is faster, at 287 ms.

Pricing. Flat per character: Starter costs €5/month with 500K characters included, then €9 per million; Pro is €49/month with 9M included, then flat overage. A free test key needs no paid plan.

Best for: writing apps, education tools, and CMSs that need measured correction quality, real-time speed, and full control of the editing UI.

2. Sapling

Sapling's Edits API is the closest architectural match to AmberPen: send text, receive a list of edits with offsets and replacements. It also offers SDKs and adjacent features like autocomplete and readability scoring.

In our AmberPen vs Sapling comparison, Sapling scored 0.470 GLEU on JFLEG — the best of the rest — but its CWEB precision of 23.6% means more than three of every four edits it proposed on web text did not match a human annotation. Median latency was 620 ms, roughly three times AmberPen's. Sapling bills per character with volume tiers (from $25 per million characters at entry, July 2026 list price; CJK text costs 2.5×).

Best for: teams that want a mature neural API with a broader writing-assistant feature set, and can tolerate higher latency and a noisier suggestion stream.

3. GrammarBot Neural

GrammarBot Neural is a focused grammar-correction API with a simple request and response. It posted the strongest CWEB precision in our benchmarks — 40.8% — and the highest CWEB F0.5 score, which weights precision over recall. On low-error-density text it proposes fewer unwanted edits than anything else we tested.

The trade-offs: it trailed on JFLEG fluency (0.413 GLEU) and was the slowest hosted API we measured, with a 1,000 ms median and a 4.4-second p99 — workable for batch checking, noticeable in an as-you-type interface. See the AmberPen vs GrammarBot Neural comparison.

Best for: batch and editorial workflows where precision matters more than speed or fluency rewriting.

4. LanguageTool

LanguageTool is the veteran: an open-source engine built on thousands of hand-written rules plus statistical spell checking, with broad multilingual support. You can call its hosted API (a rate-limited free tier plus paid plans) or self-host the server for full control.

Rules are fast and precise for the patterns they encode, and LanguageTool had the lowest median latency of the hosted APIs at 287 ms. The ceiling is recall: on CWEB it found 18.3% of annotated errors — roughly one in five — because an error no rule anticipates is invisible to it. Our AmberPen vs LanguageTool comparison shows the contextual errors it systematically misses. For many products, though, "free, self-hosted, and catches the classics" is the right trade.

Best for: budget-constrained or compliance-driven teams that want self-hosting and multilingual breadth, and can accept a recall ceiling.

5. Harper

Harper is a free, open-source grammar checker that runs entirely on the user's device — a Rust core with JavaScript bindings, editor plugins, and an Obsidian integration. It is not a hosted API at all: you embed it, and text never leaves the machine. At around 2 ms per sentence in-process, it is effectively instant.

The cost is quality and scope. In our AmberPen vs Harper comparison, Harper found 13.8% of CWEB errors at 5.8% precision — low numbers partly driven by a characteristic failure mode of rewriting unfamiliar names and terms into common dictionary words. It is also English-only.

Best for: offline-first apps, privacy-maximalist products, and anywhere "good enough, free, and local" beats "best quality."

6. Trinka

Trinka targets academic, technical, and enterprise writing: formal tone, discipline-specific terminology, consistency checks, and style rules managed centrally by an admin. It offers an API and SDK, a confidential-data plan with zero retention, and an on-premise deployment for regulated environments.

Pricing is custom and enterprise-oriented, and Trinka does not publish latency figures, so evaluate it on your own documents. If your users write journal submissions, medical documentation, or legal text, its specialization is the draw; general-purpose consumer writing is less its focus.

Best for: publishers, universities, and regulated industries that need domain specialization and deployment control.

7. Grammarly's developer platform

Grammarly is the name most people search for, so it deserves a direct answer: its developer platform does not offer a grammar-correction endpoint. The current enterprise APIs cover analytics, license management, writing scores, AI detection, and plagiarism detection. You can evaluate documents at scale and get a score back — but you cannot get a list of corrections to render in your own UI.

That makes Grammarly's APIs a fit for measuring writing quality across an organization, not for building a writing assistant. If corrections are the requirement, the other six entries here are the comparison set.

Best for: enterprises that want writing-quality scoring and policy analytics, not an embeddable corrector.

How to choose

  • Building a writing app or editor integration: you need structured edits and low latency. Shortlist AmberPen and Sapling; benchmark both on your text.
  • Education products: explanations matter as much as corrections. AmberPen's evaluate mode returns a reason for every edit.
  • CMSs and editorial pipelines: batch tolerance opens up GrammarBot Neural's precision; per-character pricing decides at volume.
  • Offline, air-gapped, or zero-budget: Harper for in-process English checking, self-hosted LanguageTool for a server and multilingual breadth.
  • Academic or regulated writing: Trinka, or AmberPen, which retains no submitted text at all.

Test with your own text

Public benchmarks measure complementary behaviors — JFLEG rewards fluent rewriting, CWEB rewards restraint on mostly-correct text — and no benchmark captures your exact workload. The reliable process is to take a few hundred representative documents from your product, run them through two or three of these APIs, and compare the suggestions side by side.

You can start that test with AmberPen in minutes: create a free test key, read the getting-started guide, and check the published benchmark methodology to see exactly how we measure.

Keep reading

Going deeper on the decision

Head-to-head comparisons

Once you've chosen