Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
You can call Chrome’s built-in AI from a Node.js project without a GPU, provided the computer meets Chrome’s CPU requirements. The model runs inside Chrome: Node.js can launch and control the browser with Puppeteer, while JavaScript in a page calls the Prompt API. For text prompting, Chrome lists a CPU path requiring at least 16 GB of RAM and four CPU cores.
What “from Node.js” means
Chrome’s Prompt API uses Gemini Nano through browser APIs such as LanguageModel.availability(), LanguageModel.create() and a session’s prompt() or promptStreaming(). Chrome does not document a Node.js-native binding or server API for invoking this model. Instead, Node.js can orchestrate Chrome and exchange data with a page; the page invokes the model in Chrome’s browser context. See Chrome’s Prompt API documentation and the Puppeteer overview.
This distinction matters: installing Puppeteer does not make Gemini Nano run in the Node process. The browser, its profile, the supported host and the model’s availability are all part of the runtime.
Can Chrome’s built-in AI run without a GPU?
Yes, for text prompting, if the computer meets Chrome’s CPU route: at least 16 GB of RAM and four CPU cores. Chrome also documents a GPU route requiring strictly more than 4 GB of VRAM, but a GPU is not mandatory when the CPU requirements are satisfied. Audio input is an exception: Chrome says Prompt API audio input requires a GPU.
#1 Best Overall
Chrome currently lists Windows 10 or 11, macOS 13 or later, Linux, and ChromeOS on Chromebook Plus devices meeting the listed platform version for APIs that use foundation models. Android, iOS, and ChromeOS devices outside Chromebook Plus are not currently supported for these APIs. The Chrome profile’s storage volume must have at least 22 GB free. These requirements can change, and the model’s size can vary as Chrome updates it; check the current Prompt API hardware requirements before relying on a particular host.
Chrome says an unmetered connection is needed for the initial model download. Once downloaded, use does not require network access. Chrome also states, narrowly, that “No data is sent to Google or any third party when using the model.” That statement concerns use of the built-in model, not your application’s own data handling or any other browser behavior.
Rank #2
Set up the Node.js-to-Chrome approach
- Check Chrome’s current setup and rollout guidance. Use Chrome’s Built-in AI getting-started guide for current setup details, local development guidance and any applicable flags. These can change, so do not rely on old flag names or rollout instructions.
- Use a dedicated browser profile. Start Chrome with a profile intended for development. Avoid attaching automation to a personal profile containing authenticated sessions unless your application deliberately needs that access; browser automation can act with the permissions available to that profile.
- Load a local development page or application in Chrome. The page is where the browser-side code will feature-detect and invoke the Prompt API. Follow the current getting-started documentation for the applicable local-origin and setup requirements.
- Check availability in page JavaScript. Request the inputs and outputs your task needs. For English text, for example:
const options = { expectedInputs: [{ type: 'text', languages: ['en'] }], expectedOutputs: [{ type: 'text', languages: ['en'] }] }; if (!('LanguageModel' in self)) { throw new Error('Chrome Prompt API is not available in this page.'); } const availability = await LanguageModel.availability(options); console.log(availability);Use the options appropriate to your task; requesting unsupported input or output options can raise
NotSupportedError. - Handle the availability result before creating a session. Account for
unavailable,downloadable,downloadingandavailable. If the model must be downloaded, present a useful status and wait for it to become ready. Chrome notes that session creation can trigger a download and may require user activation, so design the page flow accordingly. - Create a session and prompt from the page. Once ready, page code can create a session and submit a prompt. A minimal text example is:
const session = await LanguageModel.create(options); const answer = await session.prompt('Explain what a Node.js event loop does in two sentences.'); console.log(answer);For longer output, use
session.promptStreaming()and consume its stream so the page can display text as it arrives. Consult the Prompt API reference for the current method signatures and supported options. - Have Node.js automate the page with Puppeteer. Node code launches or connects to Chrome, navigates to your development page and exchanges information with it. Keep the model call in the page’s JavaScript rather than treating it as a Node import. Puppeteer supports browser automation through Chrome DevTools Protocol and WebDriver BiDi; its official overview describes the library.
- Test on the actual target host and Chrome release. Availability is a runtime check, not a guarantee based on the computer’s GPU alone. Chrome version, operating system, profile storage, CPU and RAM, model download state, requested language and modality can all affect whether the requested session is available.
CPU, GPU and input type: choose the right expectation
| Use case or route | What Chrome documents | Practical implication |
|---|---|---|
| Text prompting on CPU | At least 16 GB RAM and four CPU cores | A GPU is not required if the CPU requirements and other eligibility conditions are met. |
| GPU route | Strictly more than 4 GB VRAM | A GPU may be used, but its presence alone does not establish that the API is available. |
| Prompt API audio input | GPU required | The CPU-only path described for text does not apply to audio input. |
| Model initialization | At least 22 GB free on the volume containing the Chrome profile; unmetered connection for initial download | Check storage and allow for the initial download before testing. Later use does not require a network connection. |
What this setup does—and does not—provide
This approach keeps inference in Chrome’s local model after the initial download; it is not a way to call a remote model from Node.js, nor does it provide a Node-native Prompt API. The Prompt API accepts text and can also support image or audio inputs when the requested options are supported. Declare the expected inputs and outputs for the task and handle unsupported options rather than assuming every modality is available on every device.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitchesChrome says it is working toward standardization across browsers, but the implementation described here is Chrome-specific. Do not assume that the same browser API is available in another browser or that a Puppeteer-controlled session bypasses Chrome’s hardware, platform or availability checks.
Rank #3
Or skip the browser setup
ScreenshotNeo is a website screenshot API, not a way to run Chrome’s built-in AI from Node.js. If your Node.js task is to capture a web page rather than prompt Gemini Nano, it offers a one-request option. See the ScreenshotNeo website and API documentation.
Quick Recap
Rank #4
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpScreenshotNeo removes cookie banners, popups and chat widgets before the shot; bot checks, blank pages and failed loads are never billed. It also provides an MCP server for AI agents, and includes 1,000 screenshots a month free with no card; paid plans start at $5 for 3,000. Sign up for free screenshots.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
