Dev.to WebDev πŸ›  Dev πŸ‘ 0 πŸ“– 12 min read

How Many Websites Use Next.js? 1.97M Sites, and How to Spot One With curl

As of November 16, 2026, webatla counts 1,973,502 websites running Next.js, 0.61% of the 325.8 million websites it tracks. The current number is on webatla's Next.js technology page, which is updated daily. So the quest

How Many Websites Use Next.js? 1.97M Sites, and How to Spot One With curl

As of November 16, 2026, webatla counts 1,973,502 websites running Next.js, 0.61% of the 325.8 million websites it tracks. The current number is on webatla's Next.js technology page, which is updated daily.

So the question of how many websites use Next.js has a precise answer. Ask which release those sites run and the same scan can name one for only about 750 of them. Open one of the others in a browser, though, and the console will often print the exact version in a second. That gap between what a crawler can read and what a developer can check by hand runs through this post. The growth curve and the market tables are in the longer write-up, Next.js Statistics 2026.

What one detection tells you about a site

A detection is a yes for one domain. Next.js turned up somewhere in the pages and files that domain serves, and the record answers whether the framework is present while leaving the following open.

  • Which router. App Router and Pages Router builds both count as Next.js.
  • Which release. Only about 750 of the sites expose a version at all, which gets its own section below.
  • How much of the domain runs on it. A marketing front page built with Next.js counts, even if the logged-in product behind it uses another stack.
  • How it is deployed. The count does not separate static exports, self-hosted Node.js servers and managed platforms.

The 0.61% is measured against every tracked website, parked domains and builder pages included, so it says little about how common Next.js is among sites that have a build step. Inside the 20 technologies webatla files under Static site generator, whose counts add up to 3,485,397 sites, the Next.js market share is 56.6%, with any site that runs two of them counted under both.

Checking a single domain by hand

Next.js builds leave a few default markers that anyone can see. The checks below are signals you can look for yourself, based on documented framework behavior. They are not a description of how webatla's scanner decides, none of them is proof alone, and a team that cares enough can remove or rewrite each one.

Markers in the HTML

The most dependable trace is the asset path. Next.js serves its compiled JavaScript and CSS chunks from /_next/static/, and images that go through the built-in optimizer load from /_next/image?url=....

Two config options move that path around without removing it. assetPrefix points the chunks at another host, often a CDN, so the script tags read https://cdn.example.com/_next/static/... while the HTML itself still comes from the origin. If you fetch one of those chunk URLs, the headers you get belong to the CDN, not to the server that rendered the page. basePath mounts the whole app under a subpath such as /docs, so the chunks load from /docs/_next/static/. A search for /_next/static/ still matches in both cases. The catch with basePath is that the domain root may run a different stack entirely, and a check of the home page alone will miss the Next.js part.

Each router leaves its own marks. A Pages Router page embeds its props in a script tag with the id __NEXT_DATA__ and mounts into an element with the id __next. An App Router page has no __NEXT_DATA__. It carries inline scripts that push the React Server Components payload into self.__next_f instead. That difference is the quickest way to tell the two routers apart from outside.

Response headers

next start sends X-Powered-By: Next.js unless the project sets poweredByHeader: false in its config. Plenty of teams turn it off, so a missing header tells you nothing. On App Router builds the Vary header often lists RSC and Next-Router-State-Tree, because the same URL can return HTML or an RSC payload depending on the request.

The Server header usually names whatever answered the request, which is rarely the framework itself. Expect Vercel with an x-vercel-id header next to it, Netlify with x-nf-request-id, cloudflare, or nginx when a self-hosted Node.js process sits behind a reverse proxy.

Two commands cover both groups of signals. The first prints the headers of every hop from a normal GET request, and the second counts the framework markers in the final HTML.

curl -sL -o /dev/null -D - https://example.com \
  | grep -iE '^(server|x-powered-by|x-vercel-id|x-nf-request-id|vary):'

curl -sL https://example.com \
  | grep -oE '/_next/static/|__NEXT_DATA__|self\.__next_f' | sort | uniq -c

Some sites answer curl differently from a browser because of bot rules or geographic redirects. If the output looks empty, open the Network tab in DevTools and compare before you conclude anything.

What a static export looks like

A project built with output: 'export' has no Next.js server at all. The build writes plain HTML, JavaScript and CSS files that any static host can serve. X-Powered-By: Next.js never appears, the Vary header carries no RSC entry, and the headers you see come from whatever serves the files, such as an object store, a CDN or nginx. The default image optimizer does not work in that mode, so exported sites load images from their own paths or through a custom loader rather than from /_next/image.

What survives is the HTML. The /_next/static/ chunks are there, and so is __NEXT_DATA__ or self.__next_f, depending on the router. A site that matches the HTML markers and none of the header signals may be a static export, or a server build with its headers stripped. The curl output alone cannot tell those two apart.

The browser console

With the page open in a browser, the Next.js client runtime gives away a little more. Paste the block as one expression, so the console prints all three values together.

// Paste into the DevTools console on the page you are checking
({
  version: window.next?.version,             // version string, or undefined
  appRouter: window.next?.appDir === true,   // true on App Router builds
  pagesRouter: Boolean(window.__NEXT_DATA__) // true on Pages Router pages
})

The version field often holds a full version string even on sites whose HTML and headers show none, because the client bundle sets it when it boots. With the page running you can often read more than a plain fetch of the HTML reveals. Keep that gap in mind for the next section.

The console is also where third-party scripts show their side effects. On a server-rendered page, a script that edits the DOM before React hydrates, such as a chat widget or a tag that injects markup into the body, can trigger hydration mismatch errors. Test new embeds on a production build as well, where React reports these as minified error codes rather than the readable messages you get in development.

The version column, and how not to misread it

Of the 1,973,502 Next.js sites, about 750 show a version, roughly 0.04%. webatla tracks 34 distinct values and lists the 25 most common on the technology page. Grouped by major release, the readable ones look like this.

Lollipop chart of readable Next.js version values grouped by major release: 2.x 42, 3.x 19, 4.x 33, 5.x 40, 6.x 81, 7.x 248, 8.x 68, none listed for 9 to 12, then 13 65, 14 68, 15 72, 16 2

Readable Next.js version values grouped by major release. 7.x holds 248 of about 750 values, and 16 holds 2.

7.x alone accounts for 248 values, a third of everything readable, led by 7.0.2 on 139 sites and 7.0.3 on 100. Everything from 2.x to 8.x together comes to 531 values, about 71%. Those old majors are also the only ones with full strings such as 8.0.3. For 13, 14, 15 and 16 the page shows just the major number, on 65, 68, 72 and 2 sites, and none of the 25 listed versions belongs to 9, 10, 11 or 12.

The technology page explains the skew. A release can only be attributed when the deployed build leaves a fingerprint somewhere a crawler can read it, such as a manifest, an asset path or a header, and newer releases and hosting defaults have stripped those out. So the readable part is mostly builds that predate those changes or run with permissive settings. The modern installed base is fully inside the 1.97 million count and close to invisible in the version table.

Public version figures therefore cannot tell you how exposed the web is to an advisory about a current release. If an advisory names a range inside 14.x or 15.x, the scan shows about 70 sites per major and no minor numbers at all.

Very old builds are still serving pages, too. A site on 7.x is nine major versions behind the 16 line that already shows up in this data, and the path between them crosses codemods, React upgrades and config changes. If you inherit one, plan the upgrade as a project of its own, with time set aside for each major.

Taking stock of your own Next.js versions

Since public data cannot answer the exposure question, the answer has to come from the repositories and deployments you control. The steps below are one way to build it.

  • Read the resolved version from the lockfile or from npm ls next, not the range in package.json. A range like ^14.1.0 can resolve to any later 14.x release. npm ls next prints the version that is actually installed, and npx next info adds the Node.js version and platform, which Next.js bug reports ask for.
  • Check what is deployed, not only what sits on the main branch. Run the console expression from above on each production URL and compare window.next.version with the lockfile. A mismatch means the live build is older or newer than the code you are reading.
  • Record the router next to the version. Upgrade notes for App Router and Pages Router differ, and the appRouter and pagesRouter flags tell you which one a live site uses.
  • Include static exports and apps mounted under a basePath. A static export is easy to forget because no Node.js process runs for it, and a basePath app hides under a subpath of a domain whose root may run something else. The browser check works on both.
  • When an advisory lands, match its affected range against exact versions, never against majors alone.

A spreadsheet with domain, repository, exact version, router and deploy type is enough for a small team. The point is to have it before the advisory, because building it under pressure is when sites get missed.

Reading Next.js against the React count

Next.js is a React framework, so the two counts belong side by side. React runs on 11,053,868 websites in the November 16 file. The Next.js count equals 17.9% of that, about one site for every 5.6 React sites.

Area chart of Next.js sites for every 100 React sites at each year end: 0.4 in 2018, 0.9 in 2020, 2.9 in 2022, 4.7 in 2023, 6.7 in 2024, about 10 in 2025 and 17.7 in October 2026

Next.js sites per 100 React sites at each year end, from webatla's history model. The ratio went from 4.7 at the end of 2023 to 17.7 in October 2026.

The ratio crawled for years. It stayed below one Next.js site per 100 React sites through 2020 (early years are approximate), reached 4.7 by the end of 2023 and about 10 by the end of 2025, then climbed to 17.7 in the October 2026 model month. Measured from October 2023, when the model puts it at 4.4, that is roughly a fourfold rise in three years.

The two counts come from separate detections, so 17.9% is an upper bound on the share of React-detected sites that also run Next.js. If some Next.js builds do not trigger a React detection, the real overlap is smaller.

webatla's Next.js usage statistics put the change at +448% from October 2023 to October 2026 and +117% over the last 12 months, against +35% for React over the three years.

In the history model, the Next.js count went from about one for every 23 React sites in October 2023 to about one for every 5.6 in October 2026. Public React website work now comes with Next.js conventions more often than it did three years ago, from file-based routing and server rendering to the app directory and its build pipeline.

Migrations go both ways

The technology page splits each month into four flows. Sites launch with Next.js, existing sites switch to it, sites drop it while staying online, and sites shut down. A switch or a drop records only that the scan started or stopped seeing Next.js on a domain that stayed online. Behind many of them is a rebuild or a reconfiguration, though some will be detection changes. For maintainers those middle two flows matter most.

In the last 12 months the page records 876K switches onto Next.js and 352K drops. That works out to roughly 2,400 switches onto the framework every day and close to 1,000 drops.

Dumbbell chart of existing sites that switched to Next.js and sites that dropped it each month in 2026, from 43.1K switched and 19.6K dropped in January to 98.8K switched and 58.5K dropped in October

Existing sites that switched to Next.js and sites that dropped it while staying online, each month from January to October 2026, history model.

Within 2026 the balance between the two flows shifted. From June to August, about 3.3 to 3.4 sites switched to Next.js for every one that dropped it. In September and October the drops rose to 49.1K and 58.5K, the two highest monthly figures in the series back to 2018, and the ratio fell to about 1.8 and 1.7. Switches held up at 90.7K and 98.8K. Part of that rise may be a measurement effect, and because the counting model changed in November, later months will not extend this series directly.

The data does not say where departing sites went. Over the year, more sites removed Next.js and stayed online (352K) than shut down (321K). If you build plugins, monitoring or CMS integrations aimed at Next.js sites, expect part of your churn to come from domains that stay online after Next.js disappears from them.

Headers name the platform more often than the framework

Back to that curl output. On most Next.js sites the Server header describes infrastructure, so it helps to know how large those neighbors are in the same scan.

Lollipop chart of websites per technology on November 16, 2026: Vercel 5.08M, Node.js 3.86M, Webpack 2.70M, Next.js 1.97M, Netlify 1.76M, Express 933K

Websites per technology on November 16, 2026, for Next.js and the build and hosting technologies around it. Each is a separate count.

Vercel shows up on 5,083,343 websites, Node.js on 3,863,899, Webpack on 2,703,113, Netlify on 1,760,347 and Express on 932,791. These are separate detections. A site can carry several, and the totals cannot be added or subtracted to find overlaps. The Next.js total equals 38.8% of the Vercel count, which makes 38.8% the upper limit for the share of Vercel sites running Next.js. The real overlap is not published.

Not every neighbor can show up in a header. Webpack is a build tool, so the only place to find it is the JavaScript a site ships. The platforms are the opposite case. They name themselves in the Server header whatever framework runs behind them.

The country field comes from the server IP address, so the 76.9% of Next.js sites with a known country that sit on US servers most likely reflects platform hosting more than where owners or users are.

Next.js detection and version questions

Can you spot Next.js on a site with the X-Powered-By header turned off?

Usually. The /_next/static/ asset path and the router markers in the HTML stay unless the team rewrites its build output. The header is one signal, and the easiest one to switch off.

Is there a way to tell App Router from Pages Router without the source?

Often. Pages Router pages carry the __NEXT_DATA__ script and the __next root element. App Router pages carry self.__next_f scripts instead, and window.next.appDir is true in the console.

Why do public Next.js version numbers skew so old?

Only builds that leave a readable fingerprint can be attributed, and newer releases and hosting defaults leave less of one. About 750 of 1,973,502 sites show a version, and 7.x is the most common major among them.

Did Next.js gain sites between October and November 16?

The data cannot answer that. The monthly rows are a history model that ends in October 2026, the counting model changed in November, and 1,973,502 is a count of today's file. For change, use the page's own figures, +117% over the last 12 months and +448% from October 2023 to October 2026.

Sources

πŸ“° Read the original article on Dev.to WebDev

Originally published by Dev.to WebDev. Aggregated on AIWithGhost for educational purposes β€” full credit and traffic to the original publisher.