> Enrich.chat gives AI agents verified work emails and mobiles. To use it from an agent, read https://enrich.chat/agents.md . This is the Markdown version of https://enrich.chat/blog/what-cms-does-a-website-use/

# What CMS does a website use? Five ways to check any site

Page source, response headers, file paths, a free checker and an API each show different clues. Here is the exact tell for WordPress, Shopify, Wix, Squarespace, Webflow, Drupal, Joomla, Ghost and headless builds, and when each one fails.

By Enrich.chat Editorial. Updated October 16, 2026.

**Short answer:** To find out what CMS a website uses, view the page source and search for a generator tag or a path such as wp-content, then read the response headers and try a free checker such as [WhatCMS](https://whatcms.org/). WordPress, Drupal, Joomla and Ghost name themselves in code. Shopify, Wix and Webflow leave script and image hosts. Any clue can be hidden, so treat a result as a strong lead.

## Key takeaways

- Five checks work, from quickest to most thorough: page source and generator tags, response headers, robots.txt and admin paths, a free checker or extension, and an API for a list.
- WordPress documents a Link header with rel="https://api.w.org/", Drupal sends an X-Generator header, and Ghost and Joomla write a generator meta tag. Each platform has its own tell.
- Shopify stopped setting the _shopify_y and _shopify_s cookies on January 1, 2026, so a cookie check can miss a current store. Look for cdn.shopify.com scripts instead.
- W3Techs reports WordPress on 39.7% of all websites, and 32.2% use no CMS it monitors (checked October 16, 2026). The 2024 Web Almanac found a CMS on only 8% of top-1,000 mobile sites.
- A CDN, a headless build or a custom theme can hide the CMS. Enrich.chat's /v1/company/tech returns technology names and categories for a domain, with no versions, dates or confidence scores.

## What is the fastest way to find out what CMS a website uses?

Open the page source, search for "generator", then read the response headers. WordPress, Drupal, Joomla and Ghost all name themselves in one of those two places. If neither works, paste the domain into a free checker such as [WhatCMS](https://whatcms.org/). Every method infers the answer from public traces, so treat a result as a strong lead, not proof.

A CMS, or content management system, is the software a site's owners use to write and publish pages. Some sites run one on their own server, such as WordPress or Drupal. Some use a hosted builder, such as Wix or Squarespace. Others keep the CMS behind an API, which is called a headless setup. The [2025 Web Almanac](https://almanac.httparchive.org/en/2025/cms) describes a headless or composable CMS as one that separates content management from the site or app that shows it.

*Five ways to check what CMS a website uses*

| Way | Best for | What it shows | Where it fails |
| --- | --- | --- | --- |
| 1. Page source and generator tags | One site, when you want the evidence | A generator meta tag, asset paths and script hosts | Owners can remove the tag, and a headless page shows only its front end |
| 2. Response headers | Confirming a clue | Headers such as X-Generator, Link and X-Powered-By | A CDN or proxy can add, change or remove them |
| 3. Robots.txt, admin and API paths | Open-source systems | Default robots.txt rules, login folders and API roots | Owners can move, rename or block them |
| 4. Extension or free checker | A quick answer on one site | A named CMS, plus other tools | It reads the same public clues, one site at a time |
| 5. API | A list of domains | Rows you can store and re-run | Cost and limits, and the result is still an inference |

For click-by-click steps on view-source, DevTools, DNS records and bulk scripts, read our guide to [what technology a website uses](https://enrich.chat/blog/what-technology-does-a-website-use/). This page is the CMS version. It gives the exact tell for each platform and the cases where the tell fails.

## How do you tell WordPress, Shopify, Wix and the other big platforms apart?

Each platform leaves a different tell, and Figure 1 lists the strongest single one for eight of them. Start with the likeliest answer. [W3Techs](https://w3techs.com/technologies/overview/content_management) reports that WordPress runs on 39.7% of all websites, while 32.2% use none of the content management systems it monitors (checked October 16, 2026).

*Share of websites by CMS, W3Techs, October 16, 2026*

| CMS | Share of all websites | Share of sites with a known CMS |
| --- | --- | --- |
| WordPress | 39.7% | 58.4% |
| Shopify | 5.3% | 7.9% |
| Wix | 4.2% | 6.2% |
| Squarespace | 2.4% | 3.6% |
| Joomla | 1.1% | 1.6% |
| Webflow | 0.8% | 1.2% |
| Drupal | 0.6% | 0.9% |
| Ghost | 0.1% | 0.1% |

The odds shift with site size. The [2025 Web Almanac](https://almanac.httparchive.org/en/2025/cms) says that among the top 10,000 sites WordPress holds about 58% of CMS use and Drupal about 6% to 7%, while Wix and Shopify are almost absent. A big company site is therefore more likely to run WordPress, Drupal or a custom system than a hosted builder.

**Figure 1: The strongest single tell for eight CMS platforms.** A table of eight platforms with where to look and the tell. WordPress: a Link response header with rel https://api.w.org/. Shopify: page source with scripts from cdn.shopify.com. Wix: page source with images from static.wixstatic.com. Squarespace: add ?format=json to a page URL. Webflow: page source with a data-wf-site attribute on the html tag. Drupal: an X-Generator response header reading Drupal 10. Joomla: a generator meta tag whose value starts with Joomla. Ghost: a generator meta tag reading Ghost with a version number.

*The strongest single tell for each platform. Sources: the developer docs and source files linked in the sections below, and the open [webappanalyzer fingerprints](https://github.com/enthec/webappanalyzer).*

### How can you tell if a site runs WordPress?

Search the source for `wp-content` or `wp-includes`. The open [WordPress fingerprint](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/w.json) matches stylesheet and script paths in those folders. WordPress also prints a generator tag, `<meta name="generator" content="WordPress x.y">`, and writes a generator line into its feeds, as its [developer reference](https://developer.wordpress.org/reference/functions/get_the_generator/) shows.

The REST API announces itself too. A `Link` header with `rel="https://api.w.org/"` points to the API root, which is usually `/wp-json/`. The same link sits in the page head, per the [WordPress REST API handbook](https://developer.wordpress.org/rest-api/using-the-rest-api/discovery/). With plain permalinks, the root is `?rest_route=/`. The fingerprint also reads an `X-Pingback` header.

One caution. WordPress lets owners move the folder with `WP_CONTENT_DIR` and `WP_CONTENT_URL`, as the [wp-config guide](https://developer.wordpress.org/advanced-administration/wordpress/wp-config/) explains, so a missing wp-content path does not rule it out. A WooCommerce shop is WordPress too, because the WooCommerce fingerprint lists WordPress as required.

### How can you tell if a site runs Shopify?

Look for scripts loaded from `cdn.shopify.com` and a JavaScript variable named `Shopify`. Both are in the open [Shopify fingerprint](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/s.json), which scores the bare variable at only 25 out of 100 confidence, so pair it with a second clue. The fingerprint also reads the `x-shopid` and `x-shopify-stage` response headers.

Shopify's docs explain why the script host is so common. Its [content_for_header object](https://shopify.dev/docs/api/liquid/objects/content_for_header) returns all scripts required by Shopify, and every theme must include it in theme.liquid. A store built on a hosted theme also serves its cart as JSON at `/cart.js`, and `window.Shopify.routes.root` is the documented base for those URLs, per the [Ajax API docs](https://shopify.dev/docs/api/ajax). The same page says the Ajax API cannot be used on a Shopify custom storefront, so a headless Shopify store will not answer `/cart.js`.

Skip the old cookie test. The fingerprint still lists `_shopify_y` and `_shopify_s`, but Shopify's [developer changelog](https://shopify.dev/changelog/shopifyy-and-shopifys-cookies-will-no-longer-be-set) says it stopped setting both on merchant storefronts on January 1, 2026.

### How can you tell if a site runs Wix?

Look for images served from `static.wixstatic.com/media`. Wix's [help center](https://support.wix.com/en/article/wix-media-request-replacing-the-staticwixstaticcommedia-part-of-an-image-url-with-your-domain-name) says that address is where Wix hosts all its images, and that owners cannot replace it with their own domain, so image URLs on a Wix site keep that host. The open [Wix fingerprint](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/w.json) also matches scripts from `static.parastorage.com` and a generator tag reading Wix.com Website Builder.

For headers, Wix's [developer docs](https://dev.wix.com/docs/develop-websites/articles/contact-us/submit-support-requests) describe an `x-wix-request-id` response header, and the fingerprint treats it as a Wix clue.

### How can you tell if a site runs Squarespace?

Add `?format=json` to a page URL. Squarespace's [URL query reference](https://developers.squarespace.com/url-queries) lists it as returning website and collection data as JSON, and `?format=json-pretty` as the same data in a readable layout. A page that answers with that structure is a strong clue. Squarespace's [JSON guide](https://developers.squarespace.com/view-json-data) warns that the output is not static and is no substitute for its APIs, so use it to identify a site and nothing more.

The sources we read do not document Squarespace's page-source markers. The rest comes from the open [Squarespace fingerprint](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/s.json): a `server: Squarespace` response header and JavaScript variables named `Squarespace` and `Static.SQUARESPACE_CONTEXT`.

### How can you tell if a site runs Webflow?

Check the opening html tag for a `data-wf-site` attribute. The open [Webflow fingerprint](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/w.json) matches that attribute, a generator tag reading Webflow and a JavaScript variable named `Webflow`. Staging copies are easier to spot. Webflow's [Data API](https://developers.webflow.com/data/reference/sites/publish) documents publishing a site to a `webflow.io` subdomain, so a link that ends in webflow.io is a direct tell. On a custom domain, that attribute is the clue to look for.

### How can you tell if a site runs Drupal?

Drupal's own code names it twice. Its response subscriber sets an `X-Generator` header shaped like `Drupal 10 (https://www.drupal.org)`, per the [Drupal API reference](https://api.drupal.org/api/drupal/core%21lib%21Drupal%21Core%21EventSubscriber%21ResponseGeneratorSubscriber.php/main). The system module adds a matching `Generator` meta tag, shown in the [system_page_attachments reference](https://api.drupal.org/api/drupal/core!modules!system!system.module/function/system_page_attachments/10.x). Both give only the major version.

The open [Drupal fingerprint](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/d.json) adds the `X-Drupal-Cache` header, a script named `drupal.js`, and theme or module paths under `/sites/default/` or `/sites/all/`. Owners can strip the headers. The contributed [Remove HTTP Headers module](https://www.drupal.org/project/remove_http_headers) drops three of them by default and removes the generator tag with them, and its page says hiding Drupal is not a security measure.

### How can you tell if a site runs Joomla?

Joomla's [Document class](https://github.com/joomla/joomla-cms/blob/5.4-dev/libraries/src/Document/Document.php) sets the default generator to a string that starts with Joomla and ends with Open Source Content Management. It also has a `setGenerator` method, so a template can change the value. A generator tag that starts with Joomla is a direct tell. A different value does not rule Joomla out.

Paths help more. The back end lives at `/administrator/`, which a CMS vendor's [detector guide](https://agilitycms.com/blog/how-to-tell-what-cms-a-website-uses) also lists, and the open [Joomla fingerprint](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/j.json) matches links to `components/com_` folders. Joomla also ships a sample robots.txt, covered in the next section.

### How can you tell if a site runs Ghost?

Ghost writes a generator tag with its version, `<meta name="generator" content="Ghost x.y">`, from its `ghost_head` helper, next to an RSS link, as the [source on GitHub](https://github.com/TryGhost/Ghost/blob/6.x/ghost/core/core/frontend/helpers/ghost_head.js) shows. A reply on the [Ghost forum](https://forum.ghost.org/t/remove-generator-meta-tag/14955) says the tag goes only if you remove that helper, which also removes the other tags it writes.

The admin lives under `/ghost/`. Ghost's [Content API](https://docs.ghost.org/content-api) sits at `/ghost/api/content/` on an admin domain that can differ from the public site. The open [Ghost fingerprint](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/g.json) adds an `X-Ghost-Cache-Status` header.

## What do robots.txt, admin pages and API roots tell you?

Several open-source systems ship a default robots.txt that names their own folders. Read `yoursite.com/robots.txt`, a public file written for crawlers, and look for the folder names in the table. A login page or API root that loads is a second clue.

*Default robots.txt rules that name the system*

| Platform | What the default file names | Source |
| --- | --- | --- |
| WordPress | Blocks the admin folder and allows admin-ajax.php | [do_robots reference](https://developer.wordpress.org/reference/functions/do_robots/) |
| Drupal | /core/, /profiles/, /admin/, /user/login, /user/register | [Drupal core robots.txt](https://git.drupalcode.org/project/drupal/-/blob/11.x/robots.txt) |
| Joomla | /administrator/, /components/, /modules/, /plugins/, /libraries/ | [robots.txt.dist](https://github.com/joomla/joomla-cms/blob/5.4-dev/robots.txt.dist) |
| Ghost | /ghost/, /email/, /r/ | [Ghost default robots.txt](https://github.com/TryGhost/Ghost/blob/6.x/ghost/core/core/frontend/public/robots.txt) |
| Shopify | Generated by Shopify. Owners can replace it with a robots.txt.liquid template | [Shopify docs](https://shopify.dev/docs/storefronts/themes/seo/robots-txt) |

Joomla ships its file as a `.dist` template, so a live site's file may differ. Wix, Squarespace and Webflow publish no CMS-named robots.txt rules in the sources we read, so rely on the asset and header clues above for them.

Admin pages are weaker evidence. The usual locations are `/wp-admin/`, `/administrator/`, `/user/login` and `/ghost/`, and the same [detector guide](https://agilitycms.com/blog/how-to-tell-what-cms-a-website-uses) lists the first three, but owners can block or move them. Loading a login page is an ordinary page request. Do not try to sign in to a site you do not own, and stop if the site shows a block page.

## Can a browser extension or free checker show the CMS?

Yes. A checker reads the same clues, compares them with a library of fingerprints and returns a name. [WhatCMS](https://whatcms.org/) says it looks at generator meta tags, custom headers, common session names and thousands of other artifacts. [CRFT Lookup](https://www.crft.studio/lookup/use-cases/cms-detector) says it loads the site in a headless Chromium browser, matches over 2,500 technology fingerprints, and cannot scan intranet or password-protected pages. A CMS vendor's [guide to CMS detectors](https://agilitycms.com/blog/how-to-tell-what-cms-a-website-uses) lists more tools and notes that some sites hide their CMS on purpose, so manual and automated checks work best together.

Run two checkers and compare. If they disagree, go back to the source and look for the tells above. Our guide to [checking a website's technology](https://enrich.chat/blog/what-technology-does-a-website-use/) compares the free options and their plan prices, and our pages on [BuiltWith alternatives](https://enrich.chat/alternatives/builtwith/) and [Wappalyzer alternatives](https://enrich.chat/alternatives/wappalyzer/) cover the paid ones. Enrich.chat's free [tech stack lookup](https://enrich.chat/tools/tech-stack-lookup/) is another quick check.

## How do headless sites show up?

A headless site keeps the CMS behind an API, so the page shows a front-end framework and not the CMS. You can often name the framework and sometimes the CMS from asset hosts and API calls. Figure 2 shows what can leak through.

**Figure 2: What a headless site shows to the page.** A headless CMS such as Sanity, Strapi or Contentful sends content through an API to a front-end app built with a framework such as Next.js, which sends HTML to the browser. Three clues can show through to the page: Next.js paths under /_next/static/ and an x-powered-by header, images served from cdn.sanity.io, and an X-Powered-By header of Strapi on the CMS server's own responses. The CMS admin and content model stay behind the API.

*What a headless build can show to the page. Sources: [Next.js](https://nextjs.org/docs/app/api-reference/config/next-config-js/poweredByHeader), [Sanity](https://www.sanity.io/docs/apis-and-sdks/asset-cdn) and [Strapi](https://docs.strapi.io/cms/configurations/middlewares) docs.*

- **Next.js.** It adds an `x-powered-by` header by default, and the [Next.js docs](https://nextjs.org/docs/app/api-reference/config/next-config-js/poweredByHeader) show how to turn it off. It serves compiled files under `/_next/static/`, and its [assetPrefix option](https://nextjs.org/docs/app/api-reference/config/next-config-js/assetPrefix) can move them to a CDN host.
- **Sanity.** [Sanity's docs](https://www.sanity.io/docs/apis-and-sdks/asset-cdn) say its asset CDN is at cdn.sanity.io, so image URLs on that host suggest Sanity.
- **Strapi.** Its `poweredBy` middleware adds an `X-Powered-By` header, and the [Strapi docs](https://docs.strapi.io/cms/configurations/middlewares) list the default value as Strapi plus its web address. You see it only on responses from the Strapi server itself.
- **Contentful, Storyblok and Prismic.** The open fingerprints match Contentful assets from `ctfassets.net` ([c.json](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/c.json)), Storyblok images from `a.storyblok.com` ([s.json](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/s.json)) and Prismic images from `images.prismic.io` ([p.json](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/p.json)). They also list API hosts such as `cdn.contentful.com` and `apicdn.sanity.io`, which you can spot in the Network panel.
- **WordPress and Ghost can be headless too.** Both have public APIs, so either can serve a separate front end. The [Ghost docs](https://docs.ghost.org/content-api) say Content API keys are safe to use in browsers, so a Ghost API host can show up in network requests.

A framework is not a CMS. The [Next.js fingerprint](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/n.json) describes it as a React framework, and it can sit on any CMS. A Next.js clue answers the question about the front end. The CMS stays unknown until you find an asset host or an API call that names it.

## When is CMS detection unreliable?

Detection fails when something sits between you and the CMS, or when the owner removes the clues. A CDN changes headers, a headless build hides the CMS behind an API, and large sites often run custom systems. The [2024 Web Almanac](https://almanac.httparchive.org/en/2024/cms) detected a CMS on about 8% of the top 1,000 mobile sites, against 49% of all mobile sites, and its authors say larger businesses often use custom-built CMSs they cannot readily identify and are more likely to hide them.

**Figure 3: What a CDN or proxy changes on the way to you.** A response travels in three stages. The origin server runs the CMS and sends page code with a generator tag and asset paths, plus headers such as X-Generator or Link. A CDN or reverse proxy in front of it adds headers of its own such as Server, can set, add or remove any response header, and has a managed rule that drops X-Powered-By. Your browser or checker sees the page code and the headers the proxy left in place, so a Server header may name the CDN and not the CMS.

*How a CDN or proxy can change what a header check shows. Sources: [Cloudflare response header rules](https://developers.cloudflare.com/rules/transform/response-header-modification/), [Cloudflare managed transforms](https://developers.cloudflare.com/rules/transform/managed-transforms/reference/) and the open [Cloudflare fingerprint](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/c.json).*

- **A CDN or reverse proxy in front.** The open Cloudflare fingerprint matches a `server: cloudflare` header and a `cf-ray` header. [Cloudflare's docs](https://developers.cloudflare.com/rules/transform/response-header-modification/) say a response header rule can set, add or remove a header, and its [managed transforms](https://developers.cloudflare.com/rules/transform/managed-transforms/reference/) include one that removes X-Powered-By. A header check can name the CDN or show nothing, so read the page source as well.
- **A headless build.** The page shows the framework and not the CMS, as the section above explains.
- **Removed or changed tags.** Joomla templates can overwrite the generator string, a Drupal module strips the headers, and Ghost drops its tag only if you drop its head helper. WordPress sites can move wp-content.
- **Implied, not seen.** The WordPress fingerprint lists PHP and MySQL as implied technologies, so a checker can report them without ever seeing them.
- **Several systems under one brand.** A marketing site, a blog and a store can run on different systems, so check the exact URL you care about.
- **Checkers disagree.** The [W3Techs FAQ](https://w3techs.com/faq) says websites can hide most of their technologies and that it visits a site about once a month. For measured error rates, see our guide to [technographic data](https://enrich.chat/blog/technographic-data/).

Three habits keep you honest. Confirm with two clues from different places, such as a header and a script host. Note the date of the check. And write "not found" when nothing comes back, never "does not use".

## How do you check the CMS of many websites with Enrich.chat?

Send each domain to `GET /v1/company/tech`. Enrich.chat returns the technologies found for that domain, each with a category, or `found: false` and no charge. You read the CMS from that list. The free tier needs no key and no signup. Like every method in this guide, the result is a signal to check, not a confirmed fact.

```text
Use www.enrich.chat to look up the tech stack of each domain in my list. For every domain, tell me which technology is the website platform or CMS if the API lists one, with its category. Mark a domain with no result as not found, and do not name a CMS the API did not return.
```

Behind that prompt, your agent sends one GET request per domain. This example is illustrative, for a fictional company:

```
GET https://enrich.chat/v1/company/tech?domain=example.com

{
  "found": true,
  "domain": "example.com",
  "company": "Example Outdoor Supply",
  "technologies": [
    {"name": "WordPress", "category": "CMS"},
    {"name": "WooCommerce", "category": "Ecommerce"},
    {"name": "Cloudflare", "category": "CDN"}
  ],
  "credits_used": 5,
  "free_lookups_remaining": 9
}
```

Read the `name` field first. The category is a label, and the names and categories you get depend on the domain. Here the list shows WordPress with Cloudflare in front, and the WooCommerce entry fits the earlier point that a WooCommerce shop is WordPress. Confirm a surprising answer with one of the page-source tells above before you act on it.

A stack found uses 5 credits. A domain with no result uses 0 and does not count against your free lookups. Checking 2,000 websites needs 10,000 credits if every domain matches, which fits the Growth plan at $29 a month. A list of 40,000 websites needs 200,000 credits, which fits the Scale plan at $90 a month. Each IP address gets 10 free lookups a day with no signup, and the API answers 402 when the free limit is reached. Send requests at about one a second. See [pricing](https://enrich.chat/pricing/) for every plan.

### What does the Enrich.chat lookup not do?

- It returns names and categories only. There are no versions, so it cannot tell a current WordPress release from an old one. There are no first-seen or last-seen dates, no confidence score and no record of which clue matched.
- It takes one domain per request, so a list needs a loop or an AI agent. It takes a company website, not a company name.
- It cannot list every site that runs WordPress or Shopify. To browse companies by technology, use the [companies using directory](https://enrich.chat/companies-using/).
- It is not a browser extension. For the page in front of you, use a checker from the section above.

The same lookup is the `company_tech_stack` tool on the MCP server described on the [install page](https://enrich.chat/install/), and the free [tech stack lookup](https://enrich.chat/tools/tech-stack-lookup/) takes one domain in a browser. For the full request and response, see the [company enrichment API](https://enrich.chat/api/company-enrichment/). To go from a stack to the people who run it, pair the lookup with the company people endpoint in the [API docs](https://enrich.chat/docs/). The page on [Enrich.chat for AI agents](https://enrich.chat/agents/) shows how agents use it. To run a list without code, see the guides for [n8n](https://enrich.chat/blog/n8n-lead-enrichment/) and [Google Sheets](https://enrich.chat/integrations/google-sheets/).

## Frequently asked questions

### How do I find the CMS of a website?

View the page source (Ctrl+U in Chrome) and search for generator, wp-content, cdn.shopify.com or data-wf-site. Then read the response headers for X-Generator or a Link header with rel https://api.w.org/. If nothing shows, paste the domain into a free checker such as [WhatCMS](https://whatcms.org/) or Enrich.chat's [tech stack lookup](https://enrich.chat/tools/tech-stack-lookup/). Results are inferred from public clues, so confirm with a second method.

### How can I tell if a website is built on WordPress?

Search the page source for wp-content or wp-includes, and look for a generator tag that reads WordPress. WordPress also announces its REST API with a Link header and a head link whose rel is https://api.w.org/, and the API root is usually /wp-json/, per the [WordPress developer docs](https://developer.wordpress.org/rest-api/using-the-rest-api/discovery/). Owners can move wp-content or remove the tag, so a missing clue does not prove it is not WordPress.

### How can I tell if a site is on Shopify, Wix or Squarespace?

Shopify stores load scripts from cdn.shopify.com, Wix sites serve images from static.wixstatic.com, and Squarespace answers a ?format=json query with site data, per the [Squarespace developer docs](https://developers.squarespace.com/url-queries). Webflow puts a data-wf-site attribute on the html tag. These come from vendor docs and open fingerprints, and a headless store may show none of them.

### Can a website hide its CMS?

Yes. A contributed Drupal module strips the generator headers, a CDN rule can remove X-Powered-By, and a headless build keeps the CMS behind an API. The [2024 Web Almanac](https://almanac.httparchive.org/en/2024/cms) found a CMS on about 8% of top-1,000 mobile sites and says larger businesses often use custom CMSs. Treat not found as unknown, never as no CMS.

### What platform is a website built on if there is no generator tag?

Check the other places. Response headers such as X-Generator, Link and X-Powered-By can name the platform. Asset hosts such as cdn.shopify.com or static.wixstatic.com point to hosted builders. Default robots.txt rules name folders such as /core/ for Drupal or /ghost/ for Ghost. A path like /_next/static/ names the front-end framework, not the CMS. Run a second checker if the clues disagree.

### Is there an API to find a website's CMS?

Yes. [WhatCMS](https://whatcms.org/) offers a free or premium API plan. Enrich.chat's [GET /v1/company/tech](https://enrich.chat/api/company-enrichment/) takes one domain and returns technology names with categories. A found stack uses 5 credits and a miss uses 0. It has no versions, dates or confidence scores. See [pricing](https://enrich.chat/pricing/) for the plans.

## Sources

1. [get_the_generator (WordPress generator output)](https://developer.wordpress.org/reference/functions/get_the_generator/)
2. [REST API discovery](https://developer.wordpress.org/rest-api/using-the-rest-api/discovery/)
3. [do_robots (default WordPress robots.txt)](https://developer.wordpress.org/reference/functions/do_robots/)
4. [Editing wp-config.php (moving wp-content)](https://developer.wordpress.org/advanced-administration/wordpress/wp-config/)
5. [Shopify Ajax API](https://shopify.dev/docs/api/ajax)
6. [content_for_header Liquid object](https://shopify.dev/docs/api/liquid/objects/content_for_header)
7. [_shopify_y and _shopify_s cookies will no longer be set](https://shopify.dev/changelog/shopifyy-and-shopifys-cookies-will-no-longer-be-set)
8. [Shopify robots.txt.liquid](https://shopify.dev/docs/storefronts/themes/seo/robots-txt)
9. [Squarespace URL queries](https://developers.squarespace.com/url-queries)
10. [Squarespace: view JSON data](https://developers.squarespace.com/view-json-data)
11. [Wix Media: replacing the static.wixstatic.com/media part of an image URL](https://support.wix.com/en/article/wix-media-request-replacing-the-staticwixstaticcommedia-part-of-an-image-url-with-your-domain-name)
12. [Wix: submit support requests (x-wix-request-id)](https://dev.wix.com/docs/develop-websites/articles/contact-us/submit-support-requests)
13. [Webflow Data API: publish a site](https://developers.webflow.com/data/reference/sites/publish)
14. [ResponseGeneratorSubscriber (Drupal X-Generator header)](https://api.drupal.org/api/drupal/core%21lib%21Drupal%21Core%21EventSubscriber%21ResponseGeneratorSubscriber.php/main)
15. [system_page_attachments (Drupal generator meta tag)](https://api.drupal.org/api/drupal/core!modules!system!system.module/function/system_page_attachments/10.x)
16. [Remove HTTP Headers module](https://www.drupal.org/project/remove_http_headers)
17. [Drupal core robots.txt (11.x)](https://git.drupalcode.org/project/drupal/-/blob/11.x/robots.txt)
18. [Joomla Document class (default generator string)](https://github.com/joomla/joomla-cms/blob/5.4-dev/libraries/src/Document/Document.php)
19. [Joomla robots.txt.dist](https://github.com/joomla/joomla-cms/blob/5.4-dev/robots.txt.dist)
20. [Ghost ghost_head helper (generator tag)](https://github.com/TryGhost/Ghost/blob/6.x/ghost/core/core/frontend/helpers/ghost_head.js)
21. [Ghost default robots.txt](https://github.com/TryGhost/Ghost/blob/6.x/ghost/core/core/frontend/public/robots.txt)
22. [Ghost Content API](https://docs.ghost.org/content-api)
23. [Remove generator meta tag (Ghost forum)](https://forum.ghost.org/t/remove-generator-meta-tag/14955)
24. [Next.js poweredByHeader](https://nextjs.org/docs/app/api-reference/config/next-config-js/poweredByHeader)
25. [Next.js assetPrefix](https://nextjs.org/docs/app/api-reference/config/next-config-js/assetPrefix)
26. [Strapi middlewares configuration](https://docs.strapi.io/cms/configurations/middlewares)
27. [Sanity asset CDN](https://www.sanity.io/docs/apis-and-sdks/asset-cdn)
28. [Cloudflare managed transforms reference](https://developers.cloudflare.com/rules/transform/managed-transforms/reference/)
29. [Cloudflare response header transform rules](https://developers.cloudflare.com/rules/transform/response-header-modification/)
30. [W3Techs: usage statistics of content management systems](https://w3techs.com/technologies/overview/content_management)
31. [W3Techs FAQ](https://w3techs.com/faq)
32. [Web Almanac 2025: CMS](https://almanac.httparchive.org/en/2025/cms)
33. [Web Almanac 2024: CMS](https://almanac.httparchive.org/en/2024/cms)
34. [webappanalyzer: open Wappalyzer-format fingerprints (README)](https://github.com/enthec/webappanalyzer)
35. [WordPress, WooCommerce, Wix and Webflow fingerprints, src/technologies/w.json](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/w.json)
36. [Shopify, Squarespace, Sanity and Strapi fingerprints, src/technologies/s.json](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/s.json)
37. [Drupal fingerprint, src/technologies/d.json](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/d.json)
38. [Joomla fingerprint, src/technologies/j.json](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/j.json)
39. [Ghost fingerprint, src/technologies/g.json](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/g.json)
40. [Next.js fingerprint, src/technologies/n.json](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/n.json)
41. [Cloudflare and Contentful fingerprints, src/technologies/c.json](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/c.json)
42. [Prismic fingerprint, src/technologies/p.json](https://github.com/enthec/webappanalyzer/blob/main/src/technologies/p.json)
43. [WhatCMS](https://whatcms.org/)
44. [CRFT Lookup: CMS detector](https://www.crft.studio/lookup/use-cases/cms-detector)
45. [How to tell what CMS a website uses](https://agilitycms.com/blog/how-to-tell-what-cms-a-website-uses)

## Try this prompt

Check the CMS of a list of sites

```text
Use www.enrich.chat to look up the tech stack of each domain in my list. For every domain, tell me which technology is the website platform or CMS if the API lists one, with its category. Mark a domain with no result as not found, and do not name a CMS the API did not return.
```

## Related

- [How to check what technology a website uses](https://enrich.chat/blog/what-technology-does-a-website-use/)
- [Tech stack lookup](https://enrich.chat/tools/tech-stack-lookup/)
- [What is technographic data?](https://enrich.chat/blog/technographic-data/)