Delete Your Translation Bill: Chrome's On-Device Summar...

The last three posts in this series had an asterisk running through all of them. The built-in Chrome LLM is powerful but still an origin trial on the web. The bring-your-own models are real but download in the hundreds of megabytes. Even WebGPU, as widely as it now ships, is not quite everywhere. Useful, all of it, but none of it is the thing you wire in on a Monday without reading the fine print twice.

This post is about the part with no asterisk. Chrome has three on-device AI features that are already fully stable for websites, that need no trial token, and that quietly kill some of the most boring, most metered work a small site pays for: summarizing text, translating it, and detecting what language it is in. They are not glamorous. They are the ones that save you money first.

The boring chores that quietly meter

Think about the AI line items a small operation actually racks up. It is rarely the flashy stuff. It is a translation API charging per character every time a page shows content in another language. It is a summarization endpoint called on every long article. It is a language-detection call to decide which way to translate. None of these are exciting, and all of them tick a meter.

Chrome now ships all three as on-device APIs, stable for the web and for extensions since Chrome 138 (Chrome built-in AI status):

Summarizer condenses a block of text into a headline, a short paragraph, or key points.
Translator translates text between languages on request, for dynamic content you did not translate ahead of time.
Language Detector identifies what language a piece of text is in, which is exactly what you need before you translate it.

"Stable" is the word that matters here, and it is the reason this is the "do it now" post rather than the "prototype it" post. Unlike the general Prompt API, which is still riding an origin trial on the open web, these three are shipped and supported. You are not betting on a trial that might lapse.

Why they are the easy win

A few things make this the lowest-friction on-device AI you can adopt.

The call is free to you, forever. The work runs on the visitor's device. A translation that would meter per character through an API costs you nothing, no matter how many times it runs.
Nothing leaves the page. The text being summarized or translated stays in the browser. For anything sensitive, that is not a data-processing agreement you have to sign; it is privacy by architecture.
The hardware bar is lower than the full LLM. These are purpose-built, task-specific models, and Chrome can run them on a smaller footprint than the general Prompt API needs. Google has even introduced tiny expert models aimed at powering exactly these task APIs, so more of your visitors can actually run them (Chrome at I/O 2026).
The code is a few lines. No key, no server, no SDK. Feature-detect, create, call.

The honest limits

Two caveats, and they are the same shape as the rest of the series.

It is Chrome and Edge, on the desktop. These are Chromium built-in APIs; Firefox and Safari do not expose them, and the translator and summarizer do not run on mobile. So this is a progressive enhancement: use it where it exists, and keep a fallback for everyone else. On a site where translation is core, you still pre-render your important pages in each language for search engines and for the visitors who cannot run the local API; the on-device translator is for the dynamic, on-demand cases on top of that.
The model may need a moment on first use. As with the other built-in features, the underlying model can download the first time a visitor uses it. Feature-detect with availability(), and do not block anything important on it.

How you actually start

The shape is the same for all three: check availability, create the tool, call it. Here is the Summarizer.

// Feature-detect first. No API here means Firefox, Safari, mobile, or older Chrome.
if ('Summarizer' in self && (await Summarizer.availability()) !== 'unavailable') {
  const summarizer = await Summarizer.create({
    type: 'key-points',   // or 'tldr', 'teaser', 'headline'
    format: 'markdown',
    length: 'short',
  });
  const summary = await summarizer.summarize(longText);
  summarizer.destroy();
} else {
  useYourFallback();
}

And the Translator, which takes a language pair.

if ('Translator' in self) {
  const canDo = await Translator.availability({
    sourceLanguage: 'en',
    targetLanguage: 'es',
  });
  if (canDo !== 'unavailable') {
    const translator = await Translator.create({
      sourceLanguage: 'en',
      targetLanguage: 'es',
    });
    const spanish = await translator.translate('How do I get a refund?');
    translator.destroy();
  }
}

The Language Detector follows the same pattern and hands back a ranked list of likely languages, so you can pick a source language for the translator automatically instead of guessing. The exact option names live in Google's docs, which is where to copy from.

If you want to see the whole thing work in your own browser before you wire it in, I built a small demo for exactly that.

Try the On-Device Summarize & Translate tool — paste any text and get a summary or a translation computed entirely in your browser through these Chrome APIs, with an honest message when your browser cannot run them. Nothing you paste leaves your device.

The bottom line

The headline-grabbing on-device AI is the chatbot, but the on-device AI that pays for itself first is the quiet stuff: summarize, translate, detect. Chrome shipped all three as stable, on-device, callable-in-a-few-lines features, and they turn a recurring per-character bill into zero. Wire them in as an enhancement, keep a fallback for the browsers that lack them, and you have deleted a line item without touching your server.

If you are running lean and building client work or your own tools where every avoidable subscription matters, replacing metered API chores with free on-device ones is the exact move at the heart of my book The $20 Dollar Agency (search the title on Amazon Kindle). The short version lives on this blog, in the posts below.

Fact-check notes and sources

Summarizer, Translator, and Language Detector are stable for the web since Chrome 138, for both web pages and extensions (Chrome built-in AI APIs).
These run on-device with no server, keeping the text in the browser and costing nothing per call (Summarizer API, Translator API).
Smaller expert models for the task APIs: Google introduced ultra-small models positioned to power the task-specific APIs, lowering the availability bar versus the full Prompt API (Chrome at I/O 2026).
Chromium-only and mostly desktop: these are built-in Chrome/Edge APIs with no Firefox or Safari web equivalent, and the Translator and Summarizer do not run on mobile, so they are a progressive enhancement over a server-rendered or fallback baseline (Chrome built-in AI overview).

This post is informational, not engineering advice. Mentions of Google, Chrome, and other third parties are nominative fair use. No affiliation is implied. API status and version numbers reflect Chrome's published documentation at the time of writing and change quickly; verify against the current docs before you build.

Delete Your Translation Bill: Chrome's On-Device Summarizer and Translator Are Already Stable