How to Detect Next.js on a Website: _next, __NEXT_DATA__, React and Deployment Signals
The quickest way to detect Next.js on a website is to open the page source and search for /_next/static/, __NEXT_DATA__, and __next_f. The first term points to framework assets. The second is a strong Pages Router signal when it appears as a JSON script ID. The third can reveal the App Router when it appears in inline scripts that carry data for React. If you find Next.js assets and one of these router signals on the same page, you have strong evidence that the page was built with Next.js. Next.js
The part that trips people up is knowing what each clue actually tells you. React might be powering a chat widget while the rest of the page runs on a different stack. A Vercel response header can tell you something about deployment. And a homepage can be built with one framework while the customer dashboard uses another. If you’re preparing a redesign proposal, estimating a migration, or auditing a competitor’s website, those distinctions affect what you can confidently put in your report.
You can start with the WebBuildFinder website technology detector for an overview of the public stack. Then use the checks below to verify the exact page you’re investigating.
The fastest Next.js detection checklist
SignalWhere to find itWhat it tells you/_next/static/Page source or Network panelStrong framework evidence when the page loads JavaScript or CSS from this path<script id="__NEXT_DATA__" type="application/json">Main HTML documentStrong Pages Router evidence when the script contains Next.js page dataself.__next_fInline executable scripts in the main HTML documentStrong App Router evidence when scripts use it to carry React Server Component datax-powered-by: Next.jsMain document response headersDirect framework clue that you can verify against the HTML or assets/_next/imageImage URLs in page source or the Network panelSupporting evidence when the URL belongs to the page you’re checkingReact components in React DevToolsBrowser DevToolsShows React running in the inspected part of the pagex-vercel-id or x-vercel-cacheResponse headersIdentifies a Vercel deployment clue for that response
Start with the HTML and the requests it initiates. If the only signal you find is a response header, record which URL returned it. A header on an image from a CDN answers a different question from a header on the main HTML document.
1. Look for /_next/static/ in the page source
Open the public URL in your browser. Right-click the page and choose View Page Source, then press Ctrl + F on Windows or Cmd + F on macOS and search for /_next/static/. View Page Source lets you see the HTML delivered for the page. The Elements panel shows the live DOM after browser parsing and any changes made by scripts or extensions.
A Next.js page might include a script tag like this:
<script src="/_next/static/chunks/example-chunk.js" async></script>
The filename above is illustrative. Production builds often generate filenames that look like hashes. Focus on where the asset is loaded from and how the page uses it. A script or stylesheet referenced by the main document carries more weight than the same URL printed inside a blog post, included in a code sample, or loaded inside a separate iframe. That distinction matters on technology blogs like this one, where the very strings you’re searching for may appear in the article body.
Also check the full URL. Next.js supports an asset prefix, so a website can serve its HTML from www.example.com and load JavaScript from cdn.example.com/_next/static/. If the main document requests those assets as part of its own frontend, the different hostname is consistent with how Next.js can be deployed. Next.js
If you see references in the source, open DevTools → Network and reload with the panel open. Search for _next in the filter box. Open a matching request and check its URL, status, and initiator. A group of successful requests for framework JavaScript and CSS gives you better evidence than one stray reference. If a URL returns an HTML error page or a generic fallback, record what happened before treating it as a loaded JavaScript asset.
2. Check for __NEXT_DATA__ on Pages Router websites
Search the source for __NEXT_DATA__. Next.js uses this JSON script to serialize page data in the Pages Router so the browser can use it when React hydrates the page. Hydration is the process that makes the initial HTML interactive. Next.js
Here’s a simplified example of what the script can look like:
<script id="__NEXT_DATA__" type="application/json">
{"page":"/about","buildId":"example-build","props":{"pageProps":{}}}
</script>
Read the match in context. A real JSON script with the __NEXT_DATA__ ID is more informative than a text match buried in a JavaScript bundle. If the JSON includes fields such as page, buildId, or props, they add context. The page value can describe a route pattern, so you may see something like /products/[slug] while visiting /products/blue-jacket.
You can also check for the script using this read-only command in the browser console:
document.querySelector('script#__NEXT_DATA__[type="application/json"]') !== null
A result of true means the current document contains a matching script element. Check the surrounding source or confirm that the document also loads /_next/static/ assets. If the result is false, move on to the App Router check. The Pages Router uses __NEXT_DATA__ for this purpose, while the App Router streams data through React Server Components. Next.js
3. Look for __next_f on App Router websites
If you see several /_next/static/ requests and can’t find __NEXT_DATA__, search the original HTML for __next_f. An App Router page can include inline scripts that initialize self.__next_f and push data into it. This is associated with the React Server Component payload, sometimes called the Flight payload. The Next.js App Router client uses the queue to receive data for the initial render. GitHub
You might see patterns such as self.__next_f.push(...) in the source. The content around the match can look unfamiliar, with escaped characters, references to components, and fragments of page content. For framework identification, check that __next_f occurs in an executable script in the main document. Pair it with a successful /_next/static/ request from the same page.
For a second view, open Network, select Fetch/XHR, and click an internal link. Some App Router deployments expose route data requests during navigation or prefetching. The exact request patterns can vary with framework version, cache state, and deployment configuration. The initial HTML and the assets it loads are usually easier to verify, especially if the route data was prefetched before you clicked. Next.js
The same domain can also have pages that show different signals. For a migration audit, check a representative URL from each section and record the router evidence per URL. A single homepage check can miss the framework used by a product catalog, help center, or account area.
4. Use React DevTools to see how much of the page uses React
React DevTools can help you understand where React is running. After installing the extension, open DevTools on the page and look for the Components panel. If you can inspect a mounted component tree, look at what it represents. A tree that covers the header, product list, and navigation tells a different story from one isolated chat launcher in the corner.
React is a library used by many different setups. You might find a React application built with Vite, a React component embedded in WordPress, or a storefront built with Next.js. Finding React in the DOM or in a loaded bundle tells you to look for more specific framework evidence. The most useful follow-up is to check whether the main HTML loads its own Next.js assets and includes a router signal.
Consider a product page where React DevTools shows a product review widget. In the Network panel, you see /_next/static/ files, but their initiator is a document inside the widget’s iframe. The parent page loads a different set of scripts, and its source has neither router marker. In your report, attribute Next.js to the widget if the widget document has strong evidence. Keep the parent storefront’s framework result open until you have evidence from the storefront itself.
If you need more ways to identify React, see How to Detect React on Any Website.
5. Inspect response headers and deployment signals
Open DevTools → Network, reload the page, and select the main request under Doc. Open its Headers tab and scroll to Response Headers. If the URL redirected, inspect the final document response. The original URL may return a redirect from a different server or routing layer.
One direct clue is x-powered-by: Next.js. Next.js adds the header by default when serving responses through its server, and developers can disable it with the poweredByHeader configuration. A static export can also be served by a separate web server, which controls the response headers. That’s why HTML and asset checks still matter when the header is absent. Next.js
You may also see x-vercel-id, x-vercel-cache, or server: Vercel. These headers describe the infrastructure serving the response. For example, x-vercel-cache: HIT describes how Vercel’s cache handled a request. If a public page shows both x-vercel-id and active /_next/static/ files in the main document, you can record evidence for Vercel and Next.js, each supported by its own signal. vercel.com
If you prefer the terminal, this command makes a GET request, follows redirects, and prints the response headers while discarding the body. Replace example.com with the public URL you’re checking.
curl -sSL -D - -o /dev/null 'https://example.com/'
When redirects occur, curl displays multiple header blocks. Use the final block when reporting the headers of the destination page. Keep the original and final URLs in your notes if the redirect changes the hostname or sends you to a different site section.
How to interpret Next.js signals in a real website audit
Imagine you’re scoping a redesign for an ecommerce client. You inspect the homepage and see WordPress theme assets. Then you open the shop and find that the shop document loads /_next/static/ chunks and includes inline self.__next_f scripts. The shop document also returns x-vercel-id. Your findings can say that the public storefront uses the Next.js App Router and shows Vercel deployment signals, while the homepage exposes WordPress theme assets. That wording gives your development team a clear starting point for scoping the two sections.
The same storefront might pull catalog data from a commerce platform or content from a headless CMS. To identify those services, inspect their own public signals. Finding Next.js tells you about the frontend you’re looking at. A content API, checkout service, or database requires separate evidence. For an audit that covers those layers, see How to Identify a Website’s Complete Tech Stack.
Confidence also matters when the signals are incomplete. Suppose your detector reports React and Vercel, but you see no Next.js markup and the only apparent asset path appears as plain text. A defensible finding would be “React observed, Vercel response headers present, Next.js unconfirmed.” If the client needs a firm answer, request the project’s package manifest or build information as part of discovery. That evidence can also answer questions public inspection leaves open, such as which Next.js version the project actually deploys.
Frequently asked questions
Can I detect Next.js without installing a browser extension?
Yes. Use View Page Source and search for /_next/static/, __NEXT_DATA__, and __next_f. Then check the Network panel to confirm that the page loads the matching assets. React DevTools is optional and comes in handy when you want to see which part of the interface uses React.
Does every Next.js website use __NEXT_DATA__?
__NEXT_DATA__ is a Pages Router marker. On an App Router page, look for __next_f in executable inline scripts and corroborate it with /_next/static/ assets. Checking for both markers makes your workflow useful across the two router architectures. Next.js
Can a static website still be built with Next.js?
Yes. Next.js can export pages as static files that any suitable web server can serve. You can still look for framework-generated HTML and assets on the deployed page. The hosting provider and HTTP headers will reflect how the exported files are delivered. Next.js
Can I tell which Next.js version a website uses?
Sometimes public files contain version information, but the common checks in this guide are designed to identify the framework or router. A buildId or a hashed chunk name identifies something about the build. For a version you can verify and report, use the deployed project’s dependency or build records if you have access to them.
What should I do if a detector and my manual check disagree?
Compare the exact URLs, including any redirects. Check whether the detector scanned the homepage while you inspected a subpage, and whether the matching assets belong to the main document, an embedded frame, or a third-party widget. Record the strongest evidence you can reproduce and attach it to the URL on which you observed it.
Check a website’s framework with WebBuildFinder
Enter a public page URL into the WebBuildFinder website technology checker to get an overview of the technologies visible from that page. Review the framework and infrastructure findings, then open the same URL in your browser and verify the evidence in its source or Network panel. If you’re comparing a homepage, storefront, and blog, run each URL individually so you can see where their stacks differ.
