Chrome's Built-In AI APIs for Extension Developers: What You Can Run On-Device
Summarizer, Translator, Language Detector and the Prompt API run on-device in Chrome. Which are stable for extensions as of November 2026, hardware needs and sample code.
Adding AI to an extension used to mean an API key, a server, a monthly bill and a privacy policy explaining where users’ text goes. Chrome’s built-in AI APIs change that. They run models such as Gemini Nano locally in the browser, so text never has to leave the user’s device.
This guide covers which APIs are available to extensions as of November 2026, the hardware they need, and how to use them safely in an MV3 extension. The official reference is Chrome’s built-in AI overview.
What’s available
From Chrome’s API status table (November 2026):
| API | What it does | Extensions | Web pages |
|---|---|---|---|
| Summarizer | Summaries of different types and lengths | Stable since Chrome 138 | Stable since Chrome 138 |
| Translator | Translates text between languages | Stable since Chrome 138 | Stable since Chrome 138 |
| Language Detector | Detects the language of text | Stable since Chrome 138 | Stable since Chrome 138 |
| Prompt API | General natural-language requests to Gemini Nano, with multimodal input | Stable since Chrome 138 | Stable since Chrome 148 |
| Writer / Rewriter | Draft new text / rewrite tone and length | Developer trial | Developer trial |
| Proofreader | Grammar and spelling corrections | Developer trial | Developer trial |
Extensions got the Prompt API ten Chrome versions before regular web pages, which makes extensions a good place to experiment with it. In extensions, the Prompt API also accepts the legacy topK and temperature sampling parameters (Prompt API docs).
“Developer trial” means you can test with local flags, but you can’t ship a feature to users that depends on it.
Hardware and platform requirements
The model-based APIs (Prompt, Summarizer, Writer, Rewriter, Proofreader) only work when the user’s machine qualifies. According to Chrome’s documentation:
- Desktop only: Windows 10 or 11, macOS 13 or later, Linux, or ChromeOS on Chromebook Plus devices. Not Chrome on Android or iOS yet.
- Storage: at least 22 GB free on the volume holding the Chrome profile, because the model is downloaded on first use.
- A capable GPU or enough CPU and RAM, as detailed in the docs.
Translator and Language Detector use smaller expert models and run on desktop Chrome.
The practical consequence: always feature-detect and check availability. Some of your users will never be able to run on-device AI, so design a graceful fallback.
Checking availability
Each API exposes an availability() method. The result tells you whether the model is ready, needs downloading, or isn’t supported:
async function canSummarize() {
if (!('Summarizer' in self)) return 'unsupported';
return await Summarizer.availability(); // 'unavailable' | 'downloadable' | 'downloading' | 'available'
}
If the result is downloadable, creating a session triggers the model download. Chrome requires a user activation (such as a click) to start that download, and you can monitor progress to show a progress bar.
Example: summarise the current page from a popup
This builds on the activeTab pattern from our first extension tutorial. The popup grabs the page text with chrome.scripting, then summarises it locally:
// popup.js (manifest permissions: "activeTab", "scripting")
const out = document.getElementById('out');
document.getElementById('go').addEventListener('click', async () => {
if (!('Summarizer' in self)) {
out.textContent = 'On-device summaries are not supported on this device.';
return;
}
const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
const [{ result: text }] = await chrome.scripting.executeScript({
target: { tabId: tab.id },
func: () => (document.querySelector('article, main') || document.body).innerText,
});
const summarizer = await Summarizer.create({
type: 'key-points',
format: 'plain-text',
length: 'short',
monitor(m) {
m.addEventListener('downloadprogress', (e) => {
out.textContent = `Downloading model… ${Math.round(e.loaded * 100)}%`;
});
},
});
out.textContent = await summarizer.summarize(text.slice(0, 20000));
summarizer.destroy();
});
Notes on this code:
- The
Summarizer.create()call happens inside a click handler, which satisfies the user-activation requirement for the first download. - Very long pages exceed the model’s input limit. Trim the text, or split it and summarise in parts. The API can report input usage, so check the docs for the current limits.
- Call
destroy()to free memory when you’re done.
Using the Prompt API in an extension
The Prompt API is the flexible one: you send instructions and get text back, and it supports image and audio input as well as text. A minimal session looks like this:
const session = await LanguageModel.create({
initialPrompts: [
{ role: 'system', content: 'You classify browser tabs into one of: work, shopping, news, social, other. Reply with one word.' },
],
});
const label = await session.prompt(`Title: ${tab.title}\nURL: ${tab.url}`);
Good extension use cases include classifying or grouping tabs, extracting structured data from a page, drafting a short reply, or explaining a selected passage. These are all tasks where a small local model is “good enough” and privacy really matters. Keep prompts short and specific, and validate the output. A small model will sometimes ignore instructions, so never let its output trigger something destructive without user confirmation.
Reading tab.url and tab.title requires the tabs permission, which shows the “Read your browsing history” warning. Ask for it only if your feature truly needs it.
Privacy and Web Store considerations
On-device processing is a genuine selling point, but describe it accurately:
- Say “processed on your device” only if every path is on-device. If you fall back to a cloud API when the local model is unavailable, disclose that, and ideally ask first.
- The Chrome Web Store’s 2026 policy update requires that any data you collect is strictly necessary for your single purpose and prominently disclosed. A local-only design makes that easy. See publishing on the Chrome Web Store.
- Don’t promise results the model can’t deliver. Small models summarise well and reason less well.
Cross-browser reality
These APIs are Chrome-led. Microsoft Edge is implementing several of them, with its own model and timelines, and Firefox has its own approach to local AI for extensions. If your extension must work everywhere, treat built-in AI as a progressive enhancement: detect it, use it when present, and fall back to a simpler non-AI feature (or an opt-in cloud option) when it isn’t. Our cross-browser MV3 checklist covers the other differences.