Find Companies Using OWL Carousel (jQuery Slider API)

OWL Carousel is a jQuery plugin for responsive carousel sliders. It is old, it is everywhere, and it is one of the cleanest technographic signals you can pull off a page — because nobody installs it by accident and nobody installs it on a React app. A site running OWL Carousel is telling you, in one script tag, that its front end is jQuery-era, that somebody wanted a hero slider badly enough to add a dependency for it, and that whoever built it has not revisited that decision recently.

This post covers the exact fingerprints OWL Carousel leaves in HTML, how to check one page by hand, and how to turn that into a list of companies using OWL Carousel through the DetectZeStack API. Every response shown below is real output captured on the day this post was written, not an illustration.

What OWL Carousel Is and Why It Signals a jQuery-Era Front End

OWL Carousel turns a container of elements into a touch-enabled, responsive slider with a single call: $('.owl-carousel').owlCarousel(). Version 1.x shipped under the npm/CDN package name owl-carousel; OWL Carousel 2 lives at owlcarousel2.github.io and is the version most sites reference today. Both are jQuery plugins, and neither has seen meaningful releases in years.

That staleness is the point. When a detector reports OWL Carousel on a domain, it is reporting four things at once:

• jQuery is loaded. Not inferred from a guess — the plugin physically cannot initialize without it. The fingerprint declares the implication, so jQuery always appears alongside it in the response.
• The front end predates the component era. A team building with React, Vue, or Svelte today reaches for Swiper, Embla, or Keen-Slider. OWL Carousel means the page was built — or themed — when jQuery plugins were the default answer.
• Somebody wanted a slider. This is the part that matters for prospecting. A carousel is a deliberate merchandising decision: a hero rotator, a product strip, a testimonial cycle, a logo wall. The site has already bought into the idea; it just bought into it in 2016.
• Nobody has audited the dependency recently. OWL Carousel plus jQuery is two render-blocking dependencies for what is often one slider above the fold. Sites still shipping it have not run that audit.

Put together, that is a qualified list for three different jobs: selling a modern slider or page-builder component, pitching front-end modernization or performance work, and scoping a jQuery-removal project across a portfolio of properties.

How OWL Carousel Leaves Fingerprints on a Page

OWL Carousel is detected from the HTML a site serves — no JavaScript execution required. There are two independent signals, and either one on its own is enough.

The script tag signature (owl.carousel.js / owl.carousel.min.js)

The primary signal is a script whose source path contains owl.carousel and ends in .js. The match is on the filename pattern, not on a specific host, so all of these count:

You can confirm it on any site with one line, no API key and no browser:

$ curl -s https://circuitoftheamericas.com \
  | grep -aoE '[^"]*owl[^"]*\.(js|css)[^"]*' | sort -u
https://circuitoftheamericas.com/wp-content/themes/cota/assets/js/vendor/owl.carousel.min.js

That single line is the whole detection, and the path also tells you the delivery story: OWL Carousel arrived bundled inside a WordPress theme called cota, not as a deliberate engineering pick. Compare a site that loads it from a public CDN instead:

$ curl -s https://sparksolar.in \
  | grep -aoE '[^"]*owl[^"]*\.(js|css)' | sort -u
https://cdnjs.cloudflare.com/ajax/libs/owl-carousel/1.3.3/owl.carousel.min.js
https://cdnjs.cloudflare.com/ajax/libs/owl-carousel/1.3.3/owl.theme.min.css

The stylesheet signature (owl.carousel.css and owl.theme.*.css)

The second signal is a stylesheet link whose href ends in owl.carousel.css or owl.carousel.min.css. This matters for pages that inline or bundle the JavaScript but still pull the plugin's CSS from a separate file — a common pattern when a build step concatenates vendor scripts but leaves stylesheets alone.

One detail worth knowing before you write your own grep: OWL Carousel ships two stylesheets, owl.carousel.css (structure) and owl.theme.default.css or owl.theme.min.css (skin). Only the first matches the stylesheet fingerprint. On sparksolar.in above, the CSS on the page is owl.theme.min.css, which the stylesheet pattern does not match — the site is detected purely on its owl.carousel.min.js script tag. If you roll your own regex, match on owl\.carousel in a script src first and treat the theme stylesheet as a weaker hint.

The jQuery implication and what the version field will not tell you

The OWL Carousel fingerprint declares an implication on jQuery. In practice that means a detection never arrives alone: the response carries both entries, and you get the jQuery confirmation for free even on sites where jQuery itself is bundled into an application file the detector would not otherwise recognize.

Manual Detection in DevTools (and Where It Breaks Down)

For a single site the browser is faster than anything else. OWL Carousel registers itself as a jQuery plugin and stamps the DOM with recognizable classes once it initializes. Paste this into the DevTools console on any page:

(function () {
  var hasJQuery = typeof window.jQuery === 'function';
  var hasPlugin = hasJQuery && typeof window.jQuery.fn.owlCarousel === 'function';
  console.log({
    jquery: hasJQuery,
    owlPlugin: hasPlugin,
    containers: document.querySelectorAll('.owl-carousel').length,
    initialized: document.querySelectorAll('.owl-loaded').length
  });
})();

A page actively running the plugin prints something like:

{ jquery: true, owlPlugin: true, containers: 3, initialized: 3 }

The two counts are worth reading separately. .owl-carousel is the class you put on a container in your own markup; .owl-loaded is the class the plugin adds after it successfully initializes. A result of containers: 3, initialized: 0 means the markup is there but the plugin never ran — usually a JavaScript error further up the page. And owlPlugin: true, containers: 0 means the library ships in the bundle while nothing on this page uses it, which is exactly the kind of dead weight a performance review wants flagged.

This works perfectly for one URL. It does not survive the question that actually pays: "which of these 800 domains still run OWL Carousel?" Nobody opens DevTools 800 times, and a console screenshot is not data you can diff next quarter or hand to a sales team as a CSV.

Detect OWL Carousel With the DetectZeStack API

The DetectZeStack API returns the same answer as structured JSON, one HTTP call per domain, with the whole rest of the stack attached.

Free check with /demo (no API key)

The public /demo endpoint runs the full detector against any URL with no authentication. The plugin's own documentation site is the obvious first target:

$ curl -s "https://detectzestack.com/demo?url=https://owlcarousel2.github.io/OwlCarousel2/" \
  | python3 -m json.tool

Trimmed to the entries that matter, the real response looks like this:

{
  "url": "https://owlcarousel2.github.io/OwlCarousel2/",
  "domain": "owlcarousel2.github.io",
  "technologies": [
    {
      "name": "OWL Carousel",
      "categories": ["JavaScript libraries"],
      "confidence": 100,
      "description": "OWL Carousel is an enabled jQuery plugin that lets you create responsive carousel sliders.",
      "website": "https://owlcarousel2.github.io/OwlCarousel2/",
      "icon": "OWL Carousel.png",
      "source": "http"
    },
    {
      "name": "jQuery",
      "categories": ["JavaScript libraries"],
      "confidence": 100,
      "description": "jQuery is a JavaScript library which is a free, open-source software designed to simplify HTML DOM tree traversal and manipulation, as well as event handling, CSS animation, and Ajax.",
      "website": "https://jquery.com",
      "icon": "jQuery.svg",
      "cpe": "cpe:2.3:a:jquery:jquery:*:*:*:*:*:*:*:*",
      "source": "http"
    }
  ],
  "categories": {
    "CDN": ["Fastly"],
    "Caching": ["Varnish"],
    "JavaScript libraries": ["OWL Carousel", "jQuery", "Highlight.js"],
    "PaaS": ["GitHub Pages"],
    "SSL/TLS certificate authority": ["Let's Encrypt"],
    "UI frameworks": ["ZURB Foundation"]
  },
  "meta": { "status_code": 200, "tech_count": 8, "scan_depth": "full" },
  "cached": true,
  "response_ms": 0
}

Three things to read off that response. source: "http" means the match came from the HTML body rather than DNS or TLS, which is why meta.scan_depth has to be "full" for an OWL Carousel detection to be trustworthy — a "partial" scan means the HTTP fetch was blocked or timed out and only the DNS and TLS layers ran, so the absence of OWL Carousel in a partial result is unknown, not negative. version and cpe are absent from the OWL Carousel entry entirely because they are empty; jQuery carries a CPE, OWL Carousel does not. And cached: true with response_ms: 0 means this domain was already in the scan cache — cached and response_ms are top-level fields, not part of meta.

Confirm one domain with /check?tech=OWL%20Carousel

When you want a boolean rather than the whole stack, /check runs the same scan and returns a compact object. The technology name is matched case-insensitively, and the space must be URL-encoded:

$ curl -s "https://detectzestack.p.rapidapi.com/check?url=circuitoftheamericas.com&tech=OWL%20Carousel" \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "X-RapidAPI-Host: detectzestack.p.rapidapi.com"
{
  "domain": "circuitoftheamericas.com",
  "technology": "OWL Carousel",
  "detected": true,
  "confidence": 100,
  "version": "",
  "categories": ["JavaScript libraries"],
  "response_ms": 0,
  "cached": true
}

Note that technology comes back as the canonical OWL Carousel even if you send tech=owl%20carousel in lowercase — useful when you are normalizing names across a pipeline. confidence: 100 is what an unambiguous filename fingerprint earns; there is no fuzzy path here.

Build a list of companies using OWL Carousel with /lookup

GET /lookup?tech=OWL%20Carousel returns domains where OWL Carousel was found in DetectZeStack's prior scans. It is a reverse index over scan history, not a crawl of the open web, so treat it as a way to seed a list rather than to enumerate every site on the internet. Results paginate with limit and offset, and the limit is clamped per tier: 2 rows on the free tier, 50 on Pro, 200 on Ultra, 800 on Mega.

$ curl -s "https://detectzestack.p.rapidapi.com/lookup?tech=OWL%20Carousel&limit=2" \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "X-RapidAPI-Host: detectzestack.p.rapidapi.com"
{
  "technology": "OWL Carousel",
  "total": 146,
  "limit": 2,
  "offset": 0,
  "results": [
    {
      "domain": "sparksolar.in",
      "category": "JavaScript libraries",
      "confidence": 100,
      "version": "",
      "first_seen": "2026-06-26T16:46:11Z",
      "last_seen": "2026-09-13T05:34:03Z"
    },
    {
      "domain": "circuitoftheamericas.com",
      "category": "JavaScript libraries",
      "confidence": 100,
      "version": "",
      "first_seen": "2026-07-09T15:31:17Z",
      "last_seen": "2026-09-13T04:32:40Z"
    }
  ],
  "response_ms": 10
}

The first_seen and last_seen pair is the field most people underuse. A domain whose first_seen is months old and whose last_seen is today has been running OWL Carousel continuously across every scan in between — a stable signal, not a one-off. A large gap between the two, on the other hand, tells you the detection is stale and worth re-scanning before you put the domain on an outreach list.

Scan a prospect list with POST /analyze/batch

For domains you bring yourself, POST /analyze/batch takes up to 10 URLs per request and scans them concurrently. Each item in results carries either a result object with the single-domain shape or an error string. This three-domain call mixes two OWL Carousel sites with one that is not:

$ 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": ["sparksolar.in", "circuitoftheamericas.com", "getbootstrap.com"]}' \
  | jq '{successful, failed, total_ms,
         rows: [.results[] | {url,
           owl: ([.result.technologies[]? | select(.name == "OWL Carousel")] | length > 0),
           js: .result.categories["JavaScript libraries"],
           depth: .result.meta.scan_depth}]}'
{
  "successful": 3,
  "failed": 0,
  "total_ms": 620,
  "rows": [
    { "url": "sparksolar.in",            "owl": true,  "js": ["OWL Carousel", "jQuery"],                  "depth": "full" },
    { "url": "circuitoftheamericas.com", "owl": true,  "js": ["jQuery Migrate", "OWL Carousel", "jQuery"], "depth": "full" },
    { "url": "getbootstrap.com",         "owl": false, "js": null,                                        "depth": "full" }
  ]
}

getbootstrap.com is a deliberate negative: it has no JavaScript libraries category at all, because Bootstrap 5 dropped its jQuery dependency. The filter has to look for the exact name — a null category is not the same as a miss, and a partial scan is not the same as a negative.

Here is the whole thing as a shell pipeline. It reads domains.txt one domain per line, sends batches of 10, writes one CSV row per OWL Carousel hit with the co-detected CMS and hosting, and pushes failures and partial scans into a retry file instead of silently counting them as negatives:

#!/usr/bin/env bash
# find-owl-carousel.sh - build an OWL Carousel prospect list from domains.txt
KEY="YOUR_KEY"
HOST="detectzestack.p.rapidapi.com"

echo "requested,resolved,cms,hosting,tech_count" > owl_carousel.csv
: > owl_carousel_retry.txt

# 10 URLs per request is the /analyze/batch maximum
xargs -n 10 < domains.txt | while read -r batch; do
  urls=$(printf '%s\n' $batch | jq -R . | jq -s '{urls: .}')
  resp=$(curl -s -X POST "https://$HOST/analyze/batch" \
    -H "X-RapidAPI-Key: $KEY" \
    -H "X-RapidAPI-Host: $HOST" \
    -H "Content-Type: application/json" \
    -d "$urls")

  echo "$resp" | jq -r '.results[]
    | select(.result != null)
    | . as $item
    | $item.result as $r
    | select([$r.technologies[].name] | index("OWL Carousel"))
    | [
        $item.url,
        $r.domain,
        (($r.categories["CMS"] // []) | join(";")),
        (($r.categories["Hosting"] // []) | join(";")),
        ($r.meta.tech_count | tostring)
      ] | @csv' >> owl_carousel.csv

  # Fetch errors and DNS-only scans are unknown, not negative
  echo "$resp" | jq -r '.results[]
    | select(.error != null or .result.meta.scan_depth == "partial")
    | .url' >> owl_carousel_retry.txt

  sleep 1
done

echo "OWL Carousel hits: $(($(wc -l < owl_carousel.csv) - 1))"

A 1,000-domain list is 100 batch calls. Throughput, retries, and a Python version of this loop are covered in how to batch scan 1,000 websites.

Turning OWL Carousel Detections Into a Prospect List

A raw list of OWL Carousel domains is a starting point, not a segment. The value comes from what else is in the same response — and because /analyze returns the entire stack in one call, you already have it without a second lookup.

Run the two hits above side by side and they sort into completely different buckets. circuitoftheamericas.com comes back with CMS: ["WordPress"], Hosting: ["WP Engine"], Caching: ["WP Rocket"], SEO: ["Yoast SEO"], Form builders: ["Gravity Forms"], and 22 technologies total: a managed, professionally maintained WordPress property whose theme happens to bundle an old carousel. sparksolar.in comes back with Web servers: ["Apache HTTP Server"], UI frameworks: ["Bootstrap"], four separate CDNs including cdnjs and Google Hosted Libraries, no CMS at all, and 12 technologies: a hand-built Bootstrap site wiring libraries straight from public CDNs.

Same carousel, opposite pitches. The first is a modernization or page-speed conversation with an agency or an in-house marketing team that already pays for tooling. The second is a small custom build where the decision-maker is probably the developer. Filtering OWL Carousel hits by the presence or absence of a CMS category splits the list in half along exactly that line.

Three more filters worth applying to the same data:

• jQuery Migrate as an age marker. circuitoftheamericas.com loads jQuery Migrate alongside jQuery. Migrate exists to keep pre-3.x plugin code running on a modern jQuery build — its presence is a direct admission that legacy plugin code is still on the page. OWL Carousel plus jQuery Migrate is a stronger modernization signal than OWL Carousel alone.
• CDN delivery vs. theme bundling. A hit whose script comes from cdnjs or jsDelivr was a deliberate developer choice; a hit under /wp-content/themes/ came with the theme. The second group often does not know the carousel is there.
• Companion libraries. imagesLoaded and Slick show up in the same jQuery-era gallery stacks. A domain running two or three of them is running a whole legacy front-end, not one stray plugin.

For wiring these detections into a CRM alongside firmographic data, see building a lead enrichment pipeline with tech detection.

Accuracy Notes and Known Limits

Four caveats that will save you from a bad list.

An empty version is not a failed scan. Covered above, but it bears repeating because it is the single most common misreading: the OWL Carousel fingerprint has no version capture, so the field is empty on every hit. Filter on name, never on version.

A partial scan cannot see OWL Carousel. OWL Carousel lives in the HTML body. If meta.scan_depth is "partial", the HTTP fetch did not complete and only DNS and TLS signals are present — the result is "unknown," and treating it as "no" quietly deletes real prospects from your list. That is why the script above routes partials to a retry file.

Only the first page is scanned. A scan reads the URL you give it. A site whose homepage is a clean hero image but whose /products page runs an OWL Carousel gallery will come back negative on the root domain. If your list matters, scan two or three representative paths per domain, not just the apex.

Bundled builds are invisible. If a build step concatenates OWL Carousel into app.min.js with no owl.carousel substring left in any URL, the HTTP-layer fingerprint has nothing to match. This is rare on the kind of site that still runs the plugin — bundling and jQuery-plugin-era front ends do not usually coexist — but it is a real false-negative source, and it is the reason the DevTools check (typeof jQuery.fn.owlCarousel) can find sites the API cannot.

Get an API Key and Run Your First Scan

Start with /demo — no key, no signup, and it returns the exact response shape shown above so you can build your jq filter before you spend a single request. When you are ready to scan a list, the free tier on RapidAPI is 100 requests per month with no credit card. Paid plans start at $9/month for 1,000 requests and scale to 50,000. Every tier uses the same endpoints and the same response shape, so the pipeline you write against the free tier runs unchanged when you scale it up.

The same call that finds OWL Carousel also names the CMS, the host, the CDN, the caching layer, the analytics tags, and every other library on the page. One quota, one response, the whole stack.