How to Tell if a Website Is Built with Next.js

If you want to know whether a website is built with Next.js, the fastest answer is to view the page source and look for two things: asset URLs under /_next/static/ and an inline script with the id __NEXT_DATA__. Both are baked into how Next.js ships pages, so finding either is a strong signal and finding both is close to conclusive. Because Next.js is built on React, React detection will also fire — and that combination (React plus the Next.js-specific markers) is what distinguishes a Next.js site from a plain React app. This guide walks through every signal and how to read it in under a minute.

It sits alongside the broader framework guide, how to check if a website uses React, Vue or Angular, and the wider how to find out what technology a website uses.

What Next.js is, briefly

Next.js is a popular open-source framework built on top of React. It adds the things plain React leaves to you: server-side rendering and static generation, file-based routing, an optimised build pipeline, image optimisation and more. It is made by Vercel, which also offers the most popular hosting for it, but the framework itself is free and runs anywhere Node.js (or a compatible runtime) can run. For detection purposes, the important consequence is that Next.js has a very distinctive build output — the way it names and serves its files is consistent across sites, which is exactly what makes it identifiable.

Signal 1: the /_next/ asset paths

The single most consistent Next.js fingerprint is the /_next/ path. Every standard Next.js build serves its JavaScript chunks, CSS and other build artefacts from under /_next/static/, with hashed filenames for cache-busting. When you load a Next.js site and watch the Network tab, you will see a stream of requests to URLs like /_next/static/chunks/main-<hash>.js and /_next/static/css/<hash>.css. You will also often see /_next/image?url=... requests, which are the framework's built-in image optimisation in action. Seeing the /_next/ prefix on a site's own assets is close to definitive — it is not a path other frameworks use.

Signal 2: the NEXT_DATA script

The second, equally strong signal lives in the HTML itself. Next.js inlines a script tag that looks like this:

<script id="__NEXT_DATA__" type="application/json">{ ... }</script>

That block contains the page's props, the route, the build ID and other framework metadata as JSON. It is how Next.js hydrates the React app on the client with the data the server already computed. Open View Source (Ctrl/Cmd + U) and search the page for __NEXT_DATA__; if it is there, you are almost certainly looking at Next.js. Note that the very newest Next.js architecture (the App Router with React Server Components) can serve a more streamed payload rather than a single classic __NEXT_DATA__ blob, so its absence does not rule Next.js out — but its presence is a clear positive.

Signal 3: React underneath

Because Next.js is a React framework, every React detection signal also applies. You will typically find a <div id="__next"> (the older root container) or App Router markup, React-style hydration, and React present in the JavaScript. This is the crucial nuance: React detection fires on every Next.js site, so finding React alone does not tell you it is Next.js. The logic is layered:

• React signals present, but no /_next/ and no __NEXT_DATA__ → likely plain React, or another React framework (Gatsby, Remix).
• React signals present plus /_next/static/ plus __NEXT_DATA__ → Next.js, with high confidence.

So you read React as the foundation and the Next.js-specific markers as the thing that names the framework on top of it.

Signal 4: response headers (sometimes)

Headers occasionally help. Some Next.js deployments send an x-powered-by: Next.js response header, though many disable it, so its absence proves nothing. More useful is the hosting hint: Next.js sites are very frequently deployed on Vercel, and Vercel announces itself with server: Vercel and an x-vercel-id header. So if you see Vercel headers together with /_next/ assets, the picture is strongly Next.js-on-Vercel. Remember the caveat — Next.js runs on plenty of other hosts too — so treat Vercel headers as corroborating evidence, not a requirement. For more on reading these, see how to read a website's HTTP response headers.

The signal table

Signal	Where to find it	What it means
/_next/static/... asset URLs	Network tab, View Source	Standard Next.js build output — strong
__NEXT_DATA__ script	View Source	Next.js page data payload — strongest single signal
/_next/image?url=... requests	Network tab	Next.js image optimisation in use
<div id="__next"> root	View Source / Elements	Classic Next.js React mount point
React detected	DevTools, JS bundle	Foundation — fires for all Next.js sites
x-powered-by: Next.js header	Response headers	Direct, but often disabled
server: Vercel, x-vercel-id	Response headers	Hosting hint — Next.js often on Vercel

Method 1: View Source

The quickest single check is View Source. Open the page, press Ctrl/Cmd + U, and use the in-page find to search for __NEXT_DATA__ and /_next/. If you find the __NEXT_DATA__ script, you are done — that is Next.js. Scanning the source also lets you spot the __next root div and any inlined Next.js bootstrapping. This works because Next.js puts these markers directly in the server-rendered HTML, so they are present before any JavaScript runs — which is exactly why a static source view catches them.

Method 2: the DevTools Network tab

For a live view, open DevTools (F12), go to the Network tab and reload. Filter to JS or just watch the requests, and look for the parade of /_next/static/chunks/... files and any /_next/image calls. This method is good because it shows what the browser actually fetches, including the hashed chunk filenames that are unmistakably Next.js. It also confirms the framework is genuinely powering the page rather than appearing in some unrelated reference. If you want to identify the other libraries loading alongside Next.js, the same Network view feeds into how to check what JavaScript libraries a website uses.

Method 3: curl -I and curl

From a terminal, curl -I https://example.com prints the response headers, where you may catch x-powered-by: Next.js or the Vercel hosting headers. Dropping the -I and fetching the full HTML (piping it to a search for __NEXT_DATA__) confirms the framework from the command line without a browser. This is handy for scripting checks across many URLs, and it cross-references neatly with hosting detection — see how to find out where a website is hosted for what the headers and IP reveal about the deployment.

A worked example

Say you are sizing up a competitor's site. You open View Source and search for __NEXT_DATA__ — there it is, a fat JSON blob with a buildId and page props. That alone is enough, but you confirm: the Network tab shows a dozen /_next/static/chunks/*.js requests and a /_next/image?url=... call for the hero photo. React is detected in the bundle, as expected for Next.js. Finally, curl -I returns server: Vercel and an x-vercel-id header. Every signal lines up: this is a Next.js application deployed on Vercel, using the framework's image optimisation. In about a minute you have not just the framework but the hosting and rendering approach — a complete read of the front-end stack.

Distinguishing Next.js from other React frameworks

The React ecosystem has several frameworks, and it is worth knowing how they differ from Next.js so you do not misattribute. Gatsby is also React-based but is a static-site generator; it tends to expose a ___gatsby root and page-data.json requests rather than /_next/. Remix is another React framework with its own conventions and typically lacks the /_next/ and __NEXT_DATA__ markers. Create React App (plain client-side React) has no server-rendered data blob and no /_next/ folder. So when you see React, the presence of the /_next/ path and __NEXT_DATA__ is what specifically points to Next.js rather than one of its cousins. When those Next.js markers are absent but React is clearly present, widen your check to those alternatives. A quick rule of thumb: /_next/ says Next.js, ___gatsby and page-data.json say Gatsby, and a bare React bundle with no server-rendered data blob says a client-only React app such as Create React App or a Vite build.

It is also worth knowing the rendering modes Next.js can use, because they affect what you see in the source. With server-side rendering (SSR) or static generation (SSG), the meaningful HTML is present in View Source and the __NEXT_DATA__ blob is populated, so detection is easy and the content is crawlable. With heavy client-side rendering, the initial HTML may be sparse and fill in after hydration — but the /_next/static/ asset requests still fire, so the path signal carries the detection even when the source looks thin. Recognising which mode a site uses is a bonus insight: it tells you how the team has balanced performance, SEO and interactivity, which is exactly the kind of judgement the framework choice exists to enable.

Why the framework matters

Knowing a site runs Next.js tells you more than a label. It implies a rendering model (server-side rendering or static generation with client hydration), which has performance and SEO consequences. It suggests likely hosting (often Vercel) and a modern build pipeline. It signals the team's skill set — Next.js is a mainstream professional choice, so a site on it is usually built by people who know the modern React ecosystem. For competitive research, sales qualification, hiring or partnership scoping, the framework is one of the most informative single facts about a site, and Next.js in particular is a strong indicator of a current, well-engineered front end.

How reliable is Next.js detection?

Very reliable. The /_next/static/ asset paths and the __NEXT_DATA__ script are intrinsic to how the framework ships standard pages, so they are present on the large majority of Next.js sites and are not used by unrelated tools. The main edge case is the newest App Router architecture, which can stream its data differently and may not show a classic __NEXT_DATA__ blob — but it still serves assets from /_next/, so the path signal carries the detection. Combine the asset paths, the data script and React underneath, and you can state "this is Next.js" with genuine confidence.

The workflow

1. View Source and search for __NEXT_DATA__ and /_next/.
2. Open the Network tab and watch for /_next/static/chunks/*.js and /_next/image requests.
3. Confirm React is present as the foundation.
4. Check headers with curl -I for x-powered-by: Next.js or Vercel hosting hints.
5. Combine the signals — React plus /_next/ plus __NEXT_DATA__ means Next.js.

Go deeper

• The framework family: how to check if a website uses React, Vue or Angular.
• The whole stack: how to find out what technology a website uses.
• Where it runs: how to find out where a website is hosted.
• The libraries alongside it: how to check what JavaScript libraries a website uses.

Want the framework, hosting and full stack identified automatically? Analyse any site with StackOptic — free, no sign-up.