How to Tell If a Website Is Built With Nuxt

Nuxt is the leading meta-framework for Vue, giving Vue applications server-side rendering, static generation, file-based routing, data fetching and a complete build toolchain. Because it embeds a distinctive hydration object in the page, detecting it is straightforward: type __NUXT__ into the console or look for the #__nuxt root and _nuxt/ asset paths. This guide covers every reliable signal, the rendering architecture behind them, the look-alikes to rule out, and what a Nuxt build tells you about the team.

What is Nuxt?

Nuxt is to Vue what Next.js is to React: a meta-framework that wraps the underlying UI library with the production concerns a real application needs. It provides server-side rendering (SSR) and static-site generation (SSG) for fast first loads and good SEO, file-based routing, automatic code-splitting, data-fetching utilities, and a polished developer experience. Nuxt 3, built on Vue 3 and the Vite build tool, is the current generation, succeeding the Vue 2-based Nuxt 2. It is used across content sites, ecommerce storefronts, marketing sites and SaaS dashboards where teams want Vue's developer ergonomics plus server rendering.

For detection, the key context is twofold. First, Nuxt is built on Vue, so finding Nuxt also confirms Vue is in the stack. Second, because Nuxt server-renders pages and then hydrates them on the client, it embeds a hydration payload — the __NUXT__ object — directly in the HTML, which makes it highly detectable even before any JavaScript runs. Its presence signals a Vue team building a performance- and SEO-conscious application with modern tooling, which usually indicates real engineering investment rather than a simple template site.

How Nuxt renders and hydrates

A server-rendered Nuxt page ships fully-formed HTML plus a global window.__NUXT__ object (assigned via an inline <script>window.__NUXT__=...</script>) containing the state and data needed to hydrate the page — that is, to attach Vue's interactivity to the server-rendered markup on the client. The app mounts into a root element with id="__nuxt" (Nuxt 2 also used a nested __layout), and build assets — the JavaScript chunks, CSS and the Vue runtime — are served from a _nuxt/ path (in Nuxt 3, modern hashed chunk names under _nuxt/).

The version leaves additional clues. Nuxt 2 (Vue 2) also defines window.$nuxt, the root Vue instance, which you can inspect in the console. Nuxt 3 (Vue 3, Vite) does not expose $nuxt the same way, uses Vite-style _nuxt/ chunks, and embeds a richer __NUXT__ payload. Statically generated Nuxt sites (nuxt generate) still ship the __NUXT__ payload and _nuxt/ assets, so the signals hold for SSG as well as SSR. Knowing this — the __NUXT__ global, the #__nuxt root, and the _nuxt/ assets — makes detection quick and version-aware.

How to tell if a website uses Nuxt

Confirm at least two of the following.

1. Use the console. Type __NUXT__ and press Enter. A returned object (the hydration payload) confirms Nuxt. On Nuxt 2, $nuxt also returns the Vue instance.

2. View the page source. Search for __NUXT__, __nuxt or _nuxt/. You will find the inline window.__NUXT__=... assignment and references to _nuxt/ build assets.

3. Inspect the root element. Look for <div id="__nuxt"> (and historically <div id="__layout">) as the app mount point.

4. Check asset paths. In the Network tab, look for JavaScript and CSS served from a _nuxt/ path — characteristic of Nuxt's build output.

5. Confirm Vue. Because Nuxt is built on Vue, verify Vue is present (Vue DevTools, or the Vue runtime); Nuxt plus Vue is the expected pairing.

What the Nuxt signals look like

<div id="__nuxt"> … server-rendered markup … </div>
<script>window.__NUXT__ = (function(){ return { state:{...}, data:[...], … } })()</script>
<script type="module" src="/_nuxt/entry.[hash].js"></script>
// Nuxt 2 also: window.$nuxt  (the root Vue instance)

The combination of the __NUXT__ global, the #__nuxt root element, and _nuxt/ build assets is conclusive.

Nuxt versus other frameworks — avoiding false positives

Match the global and asset path to keep meta-frameworks distinct. Nuxt uses __NUXT__, #__nuxt and _nuxt/; Next.js (the React equivalent) uses __NEXT_DATA__, #__next and /_next/; SvelteKit uses __sveltekit_<hash> and /_app/; Remix uses __remixContext. The parallel naming between Nuxt and Next can cause confusion at a glance, but __NUXT__/_nuxt/ (Vue) versus __NEXT_DATA__/_next/ (React) are distinct — and the underlying library (Vue versus React) confirms which. The main subtlety is distinguishing Nuxt versions: $nuxt indicates Nuxt 2 (Vue 2), while its absence with modern _nuxt/ chunks indicates Nuxt 3 (Vue 3). A plain Vue SPA without SSR will show Vue but no __NUXT__ payload, so the __NUXT__ object is what specifically identifies Nuxt.

How reliable is each Nuxt signal?

The __NUXT__ global is definitive for server-rendered or statically generated Nuxt. The #__nuxt root element and _nuxt/ asset paths are equally strong and structural. The $nuxt Vue instance reliably indicates Nuxt 2. The presence of Vue reliably accompanies Nuxt. The weakest situation is a fully client-side-only Nuxt SPA with minimal SSR payload, but even then the #__nuxt root and _nuxt/ assets confirm it. As a rule, the __NUXT__ global or the _nuxt/ assets plus the #__nuxt root settle it immediately.

What a Nuxt build reveals about a site

Finding Nuxt signals a Vue development team building a server-rendered or statically generated application with modern tooling. It indicates a team that cares about performance and SEO (the reasons to use SSR/SSG over a plain SPA) and prefers Vue's ergonomics. Nuxt is common on content-heavy sites, ecommerce storefronts (often with a headless commerce backend), marketing sites that need SEO, and SaaS dashboards. Its presence tells you the site is a real application with engineering investment, not a template. The version is informative: a modern Nuxt 3 build (Vite, no $nuxt) indicates a current, well-maintained stack, while a Nuxt 2 site may be a migration candidate. If you sell developer tooling, headless commerce, hosting or front-end services, a Nuxt site marks a Vue-focused technical team.

What finding Nuxt means for sales, agencies and competitive research

For sales and prospecting, Nuxt marks a Vue engineering team building a performant, SEO-conscious app — a fit for developer tools, headless CMS/commerce, edge hosting, and front-end services. The application nature qualifies it as a real product or content operation.

For agencies and consultants, finding Nuxt tells you the client runs a Vue meta-framework, so engagements can focus on performance, SEO, headless integrations, or a Nuxt 2-to-3 migration. It signals a technical client comfortable with modern front-end architecture.

For competitive and market research, Nuxt adoption reveals a competitor's front-end choice (Vue plus SSR). Spotting it tells you they prioritise performance and SEO and work in the Vue ecosystem, useful when benchmarking technical approach and the talent they likely hire.

Nuxt in the wider stack

Nuxt sits at the centre of a Vue application stack. It implies Vue, the Vite build tool (Nuxt 3), and usually edge or Node hosting (Vercel, Netlify, Cloudflare, or a Node server) to run SSR — though statically generated Nuxt can be hosted anywhere. Content and commerce Nuxt sites frequently pair with a headless CMS (Storyblok, Sanity, Contentful) or a headless commerce backend, plus analytics and an error tracker. For an auditor, the valuable details are the Nuxt version (3 versus 2), whether the site is SSR or statically generated, the hosting that runs it, and any headless CMS or commerce backend feeding it; together these reveal a Vue team's architecture and the maturity of its stack.

A quick Nuxt confirmation walkthrough

Open the site with developer tools on the Console panel and type __NUXT__ — a returned object confirms Nuxt; on Nuxt 2, $nuxt also returns the Vue instance. View the source and search for the inline window.__NUXT__= assignment, a <div id="__nuxt"> root, and _nuxt/ asset references. In the Network tab, confirm JavaScript and CSS loading from _nuxt/. Optionally confirm Vue via Vue DevTools. The __NUXT__ global, or the #__nuxt root plus _nuxt/ assets, is enough to confirm Nuxt and indicate its version.

A quick Nuxt detection checklist

• Type __NUXT__ in the console; a returned object is conclusive ($nuxt on Nuxt 2).
• View source for the window.__NUXT__= assignment and a #__nuxt root.
• Check the Network tab for _nuxt/ build assets.
• Confirm Vue is present, since Nuxt is built on Vue.
• Use $nuxt (Nuxt 2) vs Vite _nuxt/ chunks (Nuxt 3) to gauge the version.
• Distinguish Nuxt (__NUXT__/_nuxt/, Vue) from Next.js (__NEXT_DATA__/_next/, React).

Detecting Nuxt at scale

Checking one site is quick, but mapping framework adoption across many domains — to find Vue engineering teams — calls for automation. StackOptic detects Nuxt, its version family where exposed, and thousands of other technologies from a real browser, reading the rendered page so it catches SSR and SSG builds alike. For related reading, see our guides to checking if a website uses React, Vue or Angular and telling if a website is built with Next.js, and the full Nuxt technology profile.