How to Detect Slick on Any Website (Carousel Detection API)

Slick is a jQuery carousel plugin — the one that shipped under the tagline "the last carousel you'll ever need." It powers image sliders, product carousels, testimonial rotators, and logo strips on an enormous number of production sites, largely because WordPress themes and page builders bundled it for a decade. Its last release, 1.8.1, dates back to 2017, which makes "does this site still run Slick?" a genuinely useful question for engineering audits, not just curiosity.

This post covers two ways to detect Slick: the manual browser methods for a single site, and the DetectZeStack API for scanning a whole list of domains. Every code example is copy-pasteable and uses fields that actually exist in the API response.

What Is Slick and Why Detect It

Slick, written by Ken Wheeler, turns any container of elements into a responsive, swipe-enabled carousel with one call: $('.slider').slick(). Because it is a jQuery plugin, every site that runs Slick necessarily runs jQuery too — a dependency chain that matters for detection, as we will see below.

Knowing whether a site uses Slick is useful in several contexts:

• Dependency and migration audits — Slick has been effectively unmaintained since 2017 and it pins your page to jQuery. Teams planning to drop jQuery need a real inventory of every page that still initializes a Slick carousel before they can remove the dependency.
• Sales prospecting — if you sell a modern carousel or slider component (Swiper, Splide, Embla, or your own), sites still running Slick are your most qualified prospects: they already decided a carousel belongs on the page, and their current one is a legacy dependency.
• Competitive and theme research — Slick on a page often signals an off-the-shelf WordPress theme or an older custom build rather than a modern component-based frontend. That is a fast read on how a competitor's site was put together.
• Performance reviews — Slick plus jQuery adds two render-blocking dependencies for what is often a single hero slider. Flagging it across a portfolio of pages is a common first step in a page-weight cleanup.

Manual Ways to Detect Slick on a Website

For a one-off check on a single site, the browser is the fastest tool. Slick announces itself in three independent places: the script and stylesheet tags, the CSS classes it injects into the DOM, and the jQuery plugin function it registers.

Check the Page Source for slick.min.js and slick.css

Slick ships as a JavaScript file plus two stylesheets, and the filenames are distinctive. Without running any JavaScript, a quick grep against the HTML answers the question for most sites:

curl -s https://example.com | grep -oE 'slick(\.min)?\.(js|css)|slick-theme\.css' | sort -u

A site loading Slick from a CDN typically prints something like:

slick-theme.css
slick.css
slick.min.js

To also surface the version when the CDN path includes it:

curl -s https://example.com | grep -oE 'slick-carousel[@/][0-9]+\.[0-9]+\.[0-9]+' | head -3

Look for Slick CSS Classes and the jQuery Plugin in DevTools

Once Slick initializes a carousel, it rewrites the container's DOM and stamps it with recognizable class names: slick-slider, slick-initialized, slick-track, slick-slide, and slick-dots for the pagination. It also registers itself as a jQuery plugin at $.fn.slick. Open DevTools on the target page and run this in the console:

(function () {
  var hasJQuery = typeof window.jQuery === 'function';
  var hasPlugin = hasJQuery && typeof window.jQuery.fn.slick === 'function';
  var initialized = document.querySelectorAll('.slick-initialized').length;
  console.log({ jquery: hasJQuery, slickPlugin: hasPlugin, carousels: initialized });
})();

A page running Slick prints something like:

{ jquery: true, slickPlugin: true, carousels: 2 }

The carousels count is a nice bonus: it tells you not just that Slick is loaded but how many sliders on the page actually use it. A result of slickPlugin: true, carousels: 0 means the library ships in the bundle but nothing on this particular page initializes it — dead weight worth flagging in a performance review.

Check CDN Requests in the Network Tab

Slick is most commonly delivered from a public CDN under the slick-carousel package name. Open the Network tab, filter by "slick", and look for requests to paths like:

• cdnjs: cdnjs.cloudflare.com/ajax/libs/slick-carousel/1.8.1/slick.min.js
• jsDelivr: cdn.jsdelivr.net/npm/[email protected]/slick/slick.min.js
• Self-hosted: /wp-content/themes/<theme>/js/slick.min.js or /assets/vendor/slick.min.js

The versioned CDN path is worth noting: it is exactly the signal an automated detector uses to report a version number, and the /wp-content/ variant is the tell that Slick arrived bundled inside a WordPress theme rather than as a deliberate engineering choice.

Why Manual Detection Doesn't Scale

The console method is perfect for one URL. It stops being practical the moment the question becomes "which of these 500 domains still run Slick?" — a jQuery-removal audit across a company's web properties, or a prospect list for a component vendor. Nobody opens DevTools 500 times, and a screenshot of a console is not reproducible data you can diff next quarter. For that you want an API that returns the same answer as structured JSON, one HTTP call per domain.

Detect Slick with the DetectZeStack API

The DetectZeStack /analyze endpoint returns every detected technology on a page as structured JSON. For Slick, the detector matches the two fingerprints you just verified by hand: a script tag whose path ends in slick.js or slick.min.js (capturing the version from a versioned CDN path when present), and a stylesheet link containing slick-theme.css. Because Slick cannot run without jQuery, a Slick detection also implies jQuery, so both entries appear in the response.

Try It Free with the /demo Endpoint

The public /demo endpoint runs the same detector pipeline against any URL with no authentication. It is rate-limited but perfect for confirming the response shape before you wire up a real key. Slick's own documentation site is a convenient test target because it naturally loads the library:

curl -s "https://detectzestack.com/demo?url=https://kenwheeler.github.io/slick/" | python3 -m json.tool

The response is a single JSON object. Trimmed to the relevant entries, a Slick hit looks like this:

{
  "url": "https://kenwheeler.github.io/slick/",
  "domain": "kenwheeler.github.io",
  "technologies": [
    {
      "name": "Slick",
      "categories": ["JavaScript libraries"],
      "confidence": 100,
      "description": "",
      "website": "https://kenwheeler.github.io/slick",
      "icon": "Slick.svg",
      "source": "http",
      "version": "1.8.1",
      "cpe": ""
    },
    {
      "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",
      "source": "http",
      "version": "",
      "cpe": ""
    }
  ],
  "categories": {
    "JavaScript libraries": ["Slick", "jQuery"]
  },
  "meta": { "status_code": 200, "tech_count": 4, "scan_depth": "full" },
  "cached": false,
  "response_ms": 1544
}

Single Domain Check with /analyze

For production usage, sign up on RapidAPI and call /analyze with your key. The endpoint returns the same shape as /demo but without the demo rate limit, and the response counts against your monthly quota:

curl -s "https://detectzestack.p.rapidapi.com/analyze?url=https://example.com" \
  -H "x-rapidapi-key: $RAPIDAPI_KEY" \
  -H "x-rapidapi-host: detectzestack.p.rapidapi.com" \
  | jq '.technologies[] | select(.name == "Slick")'

If Slick is detected, that pipe prints exactly the matching object; if it is not, jq outputs nothing and the command exits cleanly — easy to wire into a shell pipeline that filters a list of domains. To confirm the whole carousel stack in one pass, widen the filter to both names:

curl -s "https://detectzestack.p.rapidapi.com/analyze?url=https://example.com" \
  -H "x-rapidapi-key: $RAPIDAPI_KEY" \
  -H "x-rapidapi-host: detectzestack.p.rapidapi.com" \
  | jq '[.technologies[] | select(.name == "Slick" or .name == "jQuery") | .name]'

That returns ["Slick", "jQuery"] when the carousel is present, or just ["jQuery"] on a site that runs jQuery without Slick — which, if you are prospecting for carousel-component buyers, is a different and equally interesting list.

Scanning Multiple Domains with /analyze/batch

For lists, the POST /analyze/batch endpoint takes up to 10 URLs per request and fans them out concurrently on the server side. Each URL in the batch counts against your quota exactly as a single /analyze call would:

curl -s -X POST "https://detectzestack.p.rapidapi.com/analyze/batch" \
  -H "x-rapidapi-key: $RAPIDAPI_KEY" \
  -H "x-rapidapi-host: detectzestack.p.rapidapi.com" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://example.com", "https://example.org", "https://example.net"]}' \
  | jq '.results[] | {url: .url, slick: ([.result.technologies[]? | select(.name == "Slick")] | length > 0)}'

The batch response wraps one result object per URL in a results array, alongside total_ms, successful, and failed counters. The jq filter above reduces it to one line per domain:

{ "url": "https://example.com", "slick": true }
{ "url": "https://example.org", "slick": false }
{ "url": "https://example.net", "slick": false }

For lists longer than 10, loop over the file in chunks. A minimal worker that reads a domain list, calls /analyze once per domain, and writes one JSON line per result:

#!/usr/bin/env bash
# scan-slick.sh — usage: scan-slick.sh domains.txt > results.jsonl
set -euo pipefail

KEY="${RAPIDAPI_KEY:?set RAPIDAPI_KEY}"
HOST="detectzestack.p.rapidapi.com"

while IFS= read -r domain; do
  [ -z "$domain" ] && continue
  curl -s "https://${HOST}/analyze?url=https://${domain}" \
    -H "x-rapidapi-key: ${KEY}" \
    -H "x-rapidapi-host: ${HOST}" \
  | jq -c --arg d "$domain" '{
      domain: $d,
      slick: (.technologies[]? | select(.name == "Slick")) // null,
      jquery: ([.technologies[]? | select(.name == "jQuery")] | length > 0)
    }'
done < "$1"

Each output line is either {"domain":"...","slick":{...},"jquery":true} when Slick is present or {"domain":"...","slick":null,"jquery":false} when it is not. For higher-throughput patterns (concurrency, retries, quota handling), see Batch Scan 1,000 Websites for Tech Stack.

What the API Response Tells You

Three fields in the Slick entry deserve a closer look.

version is populated when the script path exposes it — a versioned CDN path like /slick-carousel/1.8.1/slick.min.js yields "1.8.1". When Slick is bundled into an application file by webpack or served from an unversioned theme path, version comes back as an empty string while name still reports Slick. For an audit, treat an empty string as "present, version not detectable from this signal," not as "absent." In practice, almost every versioned detection reads 1.8.1 anyway — that was the final release.

confidence reflects how definitive the matched signal is. A script tag named slick.min.js or a slick-theme.css stylesheet is an unambiguous fingerprint, so Slick detections report at confidence 100.

categories places Slick under JavaScript libraries, so it also appears in the top-level categories map next to jQuery. If your pipeline groups results by category rather than by name, that is the bucket to read.

Slick and Its Companion Technologies

Slick rarely travels alone, and the co-detections in the same response are often as informative as the Slick entry itself.

• jQuery — always present, because Slick is a jQuery plugin. The Slick fingerprint implies jQuery, so the response lists both even when jQuery's own file is bundled out of sight. See How to Detect jQuery on Any Website for the library's own fingerprints and version parsing.
• Library CDNs — when Slick loads from cdnjs.cloudflare.com or cdn.jsdelivr.net, the CDN itself is detected as a separate entry. See How to Detect cdnjs and Find Companies Using jsDelivr for how those delivery signals are matched.
• Bootstrap and WordPress — the classic legacy-frontend trio is Slick plus jQuery plus Bootstrap, very often inside a WordPress theme. When all three appear in one response, you are almost certainly looking at a themed site rather than a hand-built frontend — useful context whether you are auditing it or selling to it.

Because /analyze returns the entire stack in one response, you get all of these signals from the same call that found Slick. There is no second lookup.

Get Your API Key and Start Detecting

The free tier on RapidAPI includes 100 requests per month with no credit card — enough to test a prospect list or run a first audit pass. Paid plans start at $9/month for 1,000 requests and scale to 50,000. Every plan uses the same endpoints and the same response shape shown above, so the shell pipeline you build against the free tier works unchanged when you scale up.

Conclusion

Detecting Slick on a single page takes one line in the DevTools console: typeof $.fn.slick. Detecting it across a portfolio takes one HTTP call per domain to /analyze, or ten domains at a time through /analyze/batch. The two details that turn a yes/no answer into a real decision are the version field — nearly always 1.8.1, the 2017 final release, which is precisely why it belongs on a dependency-audit list — and the implied jQuery entry beside it, which confirms the legacy dependency chain the carousel drags along.

The same /analyze call that surfaces Slick also names every other framework, library, CDN, analytics tag, and CMS on the page. One quota, one response shape, every technology in one shot.