Detect Vue.js Website via API: A Developer Guide (2026)

If you want to check a single site for Vue by hand, our five manual Vue detection methods guide covers DevTools, page-source markers, and browser extensions. This guide is the programmatic companion: it is written for developers who need Vue.js detection inside a script, a pipeline, or a product—where the answer has to come back as JSON, at scale, without a browser in the loop.

Why Detect Vue.js Websites Programmatically

One-off checks answer curiosity. Programmatic checks power workflows:

• Technographic lead lists. If you sell Vue component libraries, Nuxt hosting, frontend audits, or migration services, a list of confirmed Vue.js sites is your addressable market. An API turns a raw domain list into that filtered list without anyone opening a browser.
• Framework migration tracking. Teams tracking a market segment want to know when a target moves from Vue 2 to Vue 3, or from a client-side SPA to Nuxt. Automated re-scans catch the change; manual checks never happen twice.
• Security and dependency audits. Vue 2 reached end-of-life at the end of 2023. A scripted scan across your own portfolio—or a client's—flags sites still serving a 2.x bundle, using the version the API extracts from the script URL when one is present.
• Enrichment inside a product. CRM enrichment, competitive dashboards, and AI agent tools all need a JSON answer to “what framework does this domain run?”—which is exactly what a detection endpoint returns.

Vue.js Detection Signals the API Looks For

Vue leaves fingerprints in the HTML a server-side request can read, which is what makes API detection possible without executing any JavaScript. The DetectZeStack API fetches the page like any HTTP client and matches these patterns:

The data-v- attribute deserves the headline. Any Vue site that uses scoped styles—which is nearly every real-world Vue codebase—ships those attributes in its rendered markup. On server-rendered and statically generated sites they are present in the raw HTML response. And even on client-only SPAs where the markup arrives empty, the Vue script URL in the document source still gives the framework away.

Detection reaches beyond the core framework, too. The API separately identifies the Vue ecosystem around it: Nuxt.js, Vuetify (UI framework), Vuex (state management), and VuePress (static site generator) each have their own signatures, and each one implies Vue.js—so a Vuetify hit confirms Vue even when Vue's own markers are minified beyond recognition.

Vue vs Nuxt Signatures

Nuxt is to Vue what Next.js is to React: the server-rendering framework built on top. The two produce different fingerprints, and the difference is informative:

• Plain Vue SPA: data-v- attributes (after hydration), a vue.js or vue.min.js script reference, and typically a near-empty <div id="app"> in the raw HTML.
• Nuxt: a <div id="__nuxt"> mount point, a window.__NUXT__ payload script carrying the server-rendered state, and asset URLs under /_nuxt/.

When the API matches a Nuxt signature it reports both Nuxt.js and Vue.js in the same response, because Nuxt implies Vue. The reverse never happens. So the presence of Nuxt.js in a result tells you the site invested in server-side rendering or static generation—a meaningfully different engineering profile from a client-only dashboard, and the same distinction that separates Next.js from plain React on the other side of the fence.

API Example: Detect Vue.js on Any Domain

Single-Domain Check with curl

The free /demo endpoint needs no API key, so you can test from any terminal right now:

$ curl -s "https://detectzestack.com/demo?url=vuejs.org" | jq '.'
{
  "url": "https://vuejs.org",
  "domain": "vuejs.org",
  "technologies": [
    {
      "name": "Vue.js",
      "categories": ["JavaScript frameworks"],
      "confidence": 100,
      "description": "Vue.js is an open-source model-view-viewmodel JavaScript framework for building user interfaces and single-page applications.",
      "website": "https://vuejs.org",
      "icon": "vue.svg",
      "source": "http",
      "version": "",
      "cpe": ""
    },
    {
      "name": "Cloudflare",
      "categories": ["CDN"],
      "confidence": 100,
      "description": "Cloudflare is a web-infrastructure and website-security company, providing content-delivery-network services, DDoS mitigation, Internet security, and distributed domain-name-server services.",
      "website": "https://www.cloudflare.com",
      "icon": "CloudFlare.svg",
      "source": "http",
      "version": "",
      "cpe": ""
    }
  ],
  "categories": { "JavaScript frameworks": ["Vue.js"], "CDN": ["Cloudflare"] },
  "meta": { "status_code": 200, "tech_count": 2, "scan_depth": "full" },
  "cached": false,
  "response_ms": 1358
}

For production use, call the RapidAPI-hosted /analyze endpoint with your key. The response shape is identical:

$ curl -s "https://detectzestack.p.rapidapi.com/analyze?url=example.com" \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "X-RapidAPI-Host: detectzestack.p.rapidapi.com" \
  | jq '.technologies[] | select(.name == "Vue.js" or .name == "Nuxt.js")'

Reading the Response: name, confidence, version, categories

Four fields do the work when you are filtering for Vue:

• technologies[].name — The exact detection names are Vue.js and Nuxt.js (and Vuetify, Vuex, VuePress for the ecosystem). Match on the full string; a substring match on "Vue" would also catch Vuetify and friends, which may or may not be what you want.
• technologies[].confidence — A matched signature reports 100. Treat any Vue.js entry in the array as a positive detection.
• technologies[].version — Populated when the Vue script URL carries a version (for example vue-2.6.14.min.js). An empty string means Vue was confirmed but the bundle name did not expose a version—common on sites that compile Vue into a hashed app bundle.
• categories — The top-level map groups results by category, so .categories["JavaScript frameworks"] gives you the framework verdict for the whole site in one lookup, with no array iteration.

Note that meta carries exactly three fields—status_code, tech_count, and scan_depth—while the timing (response_ms) and cache flag (cached) sit at the top level of the response. A scan_depth of "full" means the page fetch and all detection layers completed.

Batch-Detect Vue.js Across Hundreds of Sites

Checking domains one at a time is fine until the list has three digits. The POST /analyze/batch endpoint accepts up to 10 URLs per request and analyzes them concurrently on the server, so a 300-domain list becomes 30 API calls instead of 300—and each call returns in roughly the time of the slowest site in the group, not the sum.

$ curl -s -X POST "https://detectzestack.p.rapidapi.com/analyze/batch" \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "X-RapidAPI-Host: detectzestack.p.rapidapi.com" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["vuejs.org", "nuxt.com", "example.com"]}' \
  | jq '{successful, failed, total_ms}'
{
  "successful": 3,
  "failed": 0,
  "total_ms": 4211
}

Each item in the results array carries the URL plus a full analyze response under result (or an error string if that URL failed). To sweep a whole file of domains, chunk it into groups of 10 with xargs and keep only confirmed Vue sites:

$ cat domains.txt | xargs -n10 | while read -r chunk; do
    urls=$(echo "$chunk" | tr ' ' '\n' | jq -R . | jq -cs '{urls: .}')
    curl -s -X POST "https://detectzestack.p.rapidapi.com/analyze/batch" \
      -H "X-RapidAPI-Key: YOUR_KEY" \
      -H "X-RapidAPI-Host: detectzestack.p.rapidapi.com" \
      -H "Content-Type: application/json" \
      -d "$urls" \
    | jq -r '.results[]
        | select(.result.technologies[]?.name == "Vue.js")
        | [.result.domain,
           (if any(.result.technologies[]?; .name == "Nuxt.js") then "Nuxt.js" else "Vue SPA" end),
           (.result.technologies[] | select(.name == "Vue.js") | .version)]
        | @csv'
  done
"vuedashboard.example","Vue SPA","2.6.14"
"nuxtstore.example","Nuxt.js",""

The output is a CSV of confirmed Vue.js domains, whether each one runs Nuxt or a plain SPA, and the Vue version when the script URL exposed one. Repeated URLs are served from cache (the cached flag flips to true), which keeps re-runs fast and cheap. For a production pipeline with retries and rate-limit handling around this loop, see how to batch scan 1,000 websites; for the same pattern in Python with CSV export, the Python tutorial walks through it end to end.

Vue.js vs React vs Next.js Detection Compared

If you are building a framework-detection pipeline, Vue is one column of a wider matrix. The same API call detects the other major frameworks in the same pass—these are the signals behind each verdict:

Two practical differences stand out. First, Next.js can announce itself in an HTTP header (x-powered-by: Next.js), while Nuxt keeps its evidence in the HTML—so header-only scanners systematically undercount Nuxt. Second, both ecosystems share the implies chain: detecting Nuxt.js reports Vue.js, just as detecting Next.js reports React. Filter on the framework name you actually care about rather than assuming one entry per site. The full comparison across ecosystems lives in how to detect what JavaScript framework a website uses, with the React-specific treatment in the React detection guide.

Get Your API Key and Start Detecting

Everything above runs against two endpoints: /demo for keyless testing and /analyze (plus /analyze/batch) for production. The free tier includes 100 requests per month—enough to validate the pipeline against your own domain list before committing to anything.

Conclusion

Detecting Vue.js via API comes down to reading the fingerprints Vue leaves in server-fetched HTML: data-v- scoped-style attributes, versioned vue*.js script URLs, and—for Nuxt sites—the id="__nuxt" mount point and /_nuxt/ asset paths. One GET /analyze call returns the verdict as filterable JSON with the exact names Vue.js and Nuxt.js; POST /analyze/batch scales the same check to 10 domains per request for list-sized jobs. Start with the keyless /demo curl above, confirm the response shape, then point the batch loop at your domain list.