Find Companies Using Algolia Search via API (2026 Guide)

Algolia is a paid, hosted search product. Nobody ends up running it by accident and nobody ends up running it for free. A company that has Algolia in front of its catalogue or its documentation has already decided that the default search shipped with its CMS was not good enough, has already signed a contract, and already has an engineer who owns the index. That is a narrow and unusually qualified segment — and unlike a CMS detection, it does not drag along a long tail of hobby sites.

The awkward part is that Algolia runs in the browser. It renders no HTML, sets no generator tag, and sends no server header of its own. This post covers the one signal that does survive an ordinary HTTP fetch, how to turn it into a list of companies using Algolia through the DetectZeStack API, and — just as importantly — which Algolia sites this method will miss. Every response and every number below was captured on the day this post was written.

Why Companies Using Algolia Are Worth Identifying

Most technographic filters return a population too broad to act on. Algolia returns the opposite problem: the list is small, and that is the point. Three things are true of nearly every company on it:

• They pay for search. Algolia is not a free tier anybody scales on. A detection is a budget signal, not a preference signal.
• They have structured content worth indexing. A product catalogue, a docs corpus, a knowledge base. Somebody maintains a schema and an ingestion job.
• They own a front end. Algolia returns JSON to the browser. A rendering layer — React, Next.js, Hydrogen, a docs generator — sits between the index and the user, and a team maintains it.

As of the September 18, 2026 scan corpus, 40 domains out of 4,627 carry an Algolia detection. That is under one percent, and the names in it are consistent with the profile above: www.notion.com, linear.app, www.atlassian.com, bitwarden.com, www.prisma.io, www.digitalocean.com, render.com, expo.dev, proton.me, www.couchbase.com, www.siemens.com, www.goldmansachs.com, www.tecovas.com, and packagist.org among them. Developer tools, enterprise software, and a handful of storefronts — not a long tail.

How Algolia Is Detected on a Website

Algolia is a client-side integration. The browser loads a JavaScript client, the client queries Algolia's hosts directly, and results are painted into the DOM. Nothing about that round trip touches the origin server's response to a crawler, which means the usual fingerprints — a server header, a generator meta tag, a distinctive cookie — are all absent.

What survives is the site's own security policy. A page that talks to a third-party host and ships a Content-Security-Policy has to declare that host, or the browser blocks the request. So the CSP becomes an inventory of every external service the page uses — including the search vendor.

The algolia.net and algolianet.com search endpoints

Algolia serves queries from per-account hosts on two domains: <appid>-dsn.algolia.net for the distributed search network, and <appid>-1.algolianet.com through -3.algolianet.com as the retry fallbacks. Analytics and click tracking go to insights.algolia.io. All of those have to appear in connect-src.

You can see it with nothing but curl. Here is linear.app, which does not even bother to wildcard the hostname:

curl -sI https://linear.app | tr ';' '\n' | grep -io "[a-z0-9.-]*algolia[a-z0-9.-]*"

9RXBCYQ6DV-dsn.algolia.net

That is the account's Algolia application ID, 9RXBCYQ6DV, sitting in a response header. Other sites wildcard it instead. www.prisma.io returns .algolia.net and .algolianet.com; www.tecovas.com returns .algolia.io, .algolia.net, and .algolianet.com. Either shape is a positive.

The instantsearch.js and algoliasearch client bundles

It is worth being explicit about what does not work, because it is the thing most people try first. The Algolia JavaScript clients announce themselves through runtime properties — algoliasearch.version, __algolia, AlgoliaSearch, ALGOLIA_INSIGHTS_SRC — that only exist once the bundle has executed. DetectZeStack analyses the HTTP response without running page JavaScript, so those properties are never in scope.

Modern bundlers make this worse rather than better. A site that imports algoliasearch or instantsearch.js through Webpack or Vite ships it inside a hashed chunk with a name like main.4f2a91c.js. There is no algoliasearch.min.js script tag left to grep for. The CSP header is the signal precisely because it is the one place the integration cannot be minified away.

DocSearch widgets on documentation sites

Algolia DocSearch is the free program that powers search on a large share of open-source documentation sites. In practice it is the most common Algolia deployment on the web — and it is the hardest one to detect, for exactly the reason above: DocSearch identifies itself through the runtime property docsearch.version and nothing else.

Two consequences follow, and both matter if you are building a list:

• Algolia DocSearch is never returned as its own technology name. Across all 40 Algolia detections in the corpus, the count of rows naming DocSearch separately is zero. If a docs site is detected, it is detected as Algolia.
• A docs site is only detected if it also ships a CSP naming an Algolia host. docs.stripe.com and docs.sentry.io do, and both return Algolia. vuejs.org and docusaurus.io both run DocSearch and both come back without it — vuejs.org ships a CSP that simply does not name Algolia, and the widget's own trace is runtime-only.

Check One Domain for Algolia (Free Demo Endpoint)

The /demo endpoint needs no API key and no signup. It is the fastest way to see the exact response shape before you write a filter against it:

curl -s "https://detectzestack.com/demo?url=https://docs.stripe.com"

Trimmed to the relevant entry, the live response was:

{
  "url": "https://docs.stripe.com",
  "domain": "docs.stripe.com",
  "technologies": [
    {
      "name": "Algolia",
      "categories": ["Search engines"],
      "confidence": 100,
      "description": "Algolia offers a hosted web search product delivering real-time results.",
      "website": "https://www.algolia.com",
      "icon": "Algolia.svg",
      "source": "http"
    }
  ],
  "categories": { "Search engines": ["Algolia"] },
  "meta": { "status_code": 200, "tech_count": 6, "scan_depth": "full" },
  "cached": false,
  "response_ms": 4235
}

Three fields are worth reading carefully. source: "http" means the match came from the HTTP response rather than DNS or TLS — for Algolia it is always http, because the CSP header is the only signal. meta.scan_depth: "full" means the body and headers were both retrieved; a "partial" scan has only DNS and TLS data and cannot see Algolia at all. And response_ms and cached are top-level fields, not inside meta — a detail worth getting right before you write the jq filter.

API Example: Detect Algolia with DetectZeStack

GET /analyze — full tech stack for a single domain

Same response shape as /demo, with your quota and no per-IP cap:

curl -s "https://detectzestack.com/analyze?url=https://www.prisma.io" \
  -H "X-API-Key: YOUR_KEY"

The live result named nine technologies: Algolia, HSTS, Let's Encrypt, Linkedin Ads, Sanity, Sanity.io, Tolt, Vercel, and hCaptcha, with meta.tech_count: 9, cached: false, and response_ms: 2597. The grouped view is often the more useful one:

{
  "Advertising": ["Linkedin Ads"],
  "Affiliate programs": ["Tolt"],
  "CMS": ["Sanity.io", "Sanity"],
  "PaaS": ["Vercel"],
  "SSL/TLS certificate authority": ["Let's Encrypt"],
  "Search engines": ["Algolia"],
  "Security": ["hCaptcha", "HSTS"]
}

One request produced the search vendor, the headless CMS, the hosting platform, the ad pixel, and the affiliate tracker. That is the whole reason to detect Algolia through a stack API rather than a single-purpose script — the surrounding technologies are what make the lead qualifiable.

GET /check?tech=Algolia — yes or no with a confidence score

When you already know which technology you are asking about, /check returns a flat boolean instead of a full stack:

curl -s "https://detectzestack.com/check?url=https://www.notion.com&tech=Algolia" \
  -H "X-API-Key: YOUR_KEY"

{
  "domain": "www.notion.com",
  "technology": "Algolia",
  "detected": true,
  "confidence": 100,
  "version": "",
  "categories": ["Search engines"],
  "response_ms": 2093,
  "cached": false
}

Two notes. The tech parameter is case-insensitive and the response echoes back the canonical name, so tech=algolia returns "technology": "Algolia". And version is empty — not occasionally, but on all 40 Algolia rows in the corpus. Algolia is hosted software with no customer-visible release number in the response, and the header fingerprint captures no digits. Filter on detected, never on version.

POST /analyze/batch — scan up to 10 prospect domains at once

Batch is the endpoint you actually build a list with. Ten URLs per call, results returned in input order:

curl -s -X POST "https://detectzestack.com/analyze/batch" \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"urls":["https://linear.app","https://www.tecovas.com","https://www.mozilla.org"]}'

The live response returned "successful": 3, "failed": 0, and "total_ms": 6001. Each item in results has a url and a result holding the same object /analyze returns. linear.app and www.tecovas.com both carried Algolia; www.mozilla.org did not. Pulling just the hits:

curl -s -X POST "https://detectzestack.com/analyze/batch" \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"urls":["https://linear.app","https://www.tecovas.com","https://www.mozilla.org"]}' \
| jq -r '.results[]
    | select(.result.technologies[]?.name == "Algolia")
    | .result.domain'

linear.app
www.tecovas.com

The endpoint also speaks CSV. Add ?format=csv or send Accept: text/csv and you get one row per detected technology with URL, domain, technology, category, confidence, and error columns — which is usually what you want feeding a spreadsheet.

GET /lookup?tech=Algolia — pull domains already known to run Algolia

Everything above verifies domains you supply. /lookup goes the other direction and returns domains where Algolia was already found in a prior scan:

curl -s "https://detectzestack.com/lookup?tech=Algolia&limit=50" \
  -H "X-API-Key: YOUR_KEY"

{
  "technology": "Algolia",
  "total": 40,
  "limit": 2,
  "offset": 0,
  "response_ms": 11,
  "results": [
    {
      "domain": "www.notion.com",
      "category": "Search engines",
      "confidence": 100,
      "version": "",
      "first_seen": "2026-09-13T03:04:39Z",
      "last_seen": "2026-09-18T13:03:30Z"
    },
    {
      "domain": "bitwarden.com",
      "category": "Search engines",
      "confidence": 100,
      "version": "",
      "first_seen": "2026-04-12T07:09:29Z",
      "last_seen": "2026-09-16T18:02:01Z"
    }
  ]
}

That response was made on a free key, which is why limit came back as 2 despite asking for 50 — the parameter is clamped to the plan ceiling. Those ceilings are 2 rows on Basic (free), 50 on Pro, 200 on Ultra, and 800 on Mega. total is not clamped, so even a free key can see that 40 domains are available before deciding whether to upgrade.

Two properties make this endpoint cheap. It costs one request regardless of how many rows come back, and it responds in single-digit milliseconds because it reads an index rather than fetching anything. Page through it with offset. The honest limitation: it is a reverse index over domains DetectZeStack has previously scanned, not a crawl of the entire web. Use it as a seed list, then verify and extend with /analyze/batch.

Reading the Response: What the Rest of the Stack Tells You

An Algolia hit on its own tells you a company pays for search. The technologies sitting next to it tell you what to say to them. Across the 40 Algolia domains in the corpus, the co-occurrence counts are:

Algolia plus Next.js plus Vercel: the headless pattern

Eleven of the 40 run Next.js and six run Vercel, and the overlap is where the highest-intent accounts cluster: attio.com, nextjs.org, ripple.com, www.notion.com, www.prisma.io, and www.tigerdata.com all carry Algolia plus Vercel. Add a headless CMS — Sanity on seven domains, Contentful on six — and you have the full composable stack. A company that has assembled Algolia, a headless CMS, and managed front-end hosting has made three separate buy decisions in the same architecture, which is the clearest possible signal that a fourth is possible.

The storefront variant of this pattern is rarer in the corpus but sharper when it appears. www.tecovas.com returned Algolia, Shopify, Hydrogen, Sanity, React, Vite, Cloudflare, and Adobe Fonts in a single call — a headless Shopify build that replaced native Shopify search with Algolia and native Shopify content with Sanity. That is a retailer that has already paid to escape its platform's defaults twice.

Algolia on docs subdomains vs Algolia on storefronts

These are two different buyers wearing the same detection, and conflating them is the most common way an Algolia list underperforms.

Docs-site Algolia — docs.stripe.com, docs.sentry.io, pulsar.apache.org, jira.atlassian.com — usually means developer experience or documentation tooling owns the budget, often through the free DocSearch program rather than a contract. The buyer is a DevRel or docs lead. Note the implication for prospecting: if you only scan apex domains, you miss this segment entirely, because the docs subdomain is where the search lives. Scan docs. and developer. subdomains explicitly.

Storefront Algolia — www.tecovas.com, home.bargains, us.pg.com — means merchandising or ecommerce owns it, the contract is paid, and search relevance is tied to revenue. Different buyer, different pitch, different price tolerance. The distinguishing signal is in the same response: an Ecommerce or CMS category entry alongside the Search engines one.

Building an Algolia Prospect List End to End

Putting the pieces together — seed from /lookup, extend with your own domains, verify in batches of 10:

#!/usr/bin/env bash
set -euo pipefail
KEY="$DZS_API_KEY"

# 1. Seed from domains already known to run Algolia.
curl -s "https://detectzestack.com/lookup?tech=Algolia&limit=200" \
  -H "X-API-Key: $KEY" | jq -r '.results[].domain' > seed.txt

# 2. Verify your own prospect list, 10 domains per call.
echo "domain,algolia,stack" > algolia.csv
while read -r -a batch; do
  urls=$(printf '"https://%s",' "${batch[@]}" | sed 's/,$//')
  curl -s -X POST "https://detectzestack.com/analyze/batch" \
    -H "X-API-Key: $KEY" -H "Content-Type: application/json" \
    -d "{\"urls\":[$urls]}" \
  | jq -r '.results[]
      | select(.result != null)
      | [ .result.domain,
          (if any(.result.technologies[]?; .name == "Algolia") then "yes" else "no" end),
          ([.result.technologies[].name] | join("|"))
        ] | @csv' >> algolia.csv
  sleep 1
done < <(xargs -n 10 < prospects.txt)

echo "Algolia hits: $(grep -c ',\"yes\",' algolia.csv || true)"

A 1,000-domain list is 100 batch calls. Throughput, retry handling, and a Python version of this loop are covered in how to batch scan 1,000 websites. To join the output against firmographic data and push it into a CRM, see building a lead enrichment pipeline with tech detection.

Detection Limits, Caching, and Request Cost

Four limits are worth planning around before you build anything on this.

No CSP means no detection. This is the dominant false negative and it is structural. A site that runs Algolia but ships no Content-Security-Policy header leaves no HTTP-layer trace of it. Every negative on a CSP-less site is genuinely "unknown", and treating it as "no" silently deletes real prospects.

A partial scan cannot see Algolia. The signal is a response header. If meta.scan_depth is "partial", only DNS and TLS data came back. Route partials to a retry file rather than counting them as misses.

Change events for Algolia are noisier than they look. GET /changes?domain=example.com reports technologies added and removed between consecutive scans, and across Algolia's history in the corpus there are 17 added and 15 removed events. Those are not 32 migrations. www.atlassian.com alone accounts for 13 adds and 13 removes — a domain whose CSP varies by response, not a company that adopted and dropped Algolia thirteen times. The one-directional events are the real ones: www.notion.com, www.digitalocean.com, and www.tech.gov.sg each added it once and never removed it; ghost.org removed it once. Require several consecutive absences before treating a removal as a churn signal. Tracking website tech changes via API covers the alerting patterns that filter this out.

Batch calls are not discounted. A 10-URL /analyze/batch request is convenient, not cheaper — budget 1,000 domains as 1,000 requests. /lookup is the exception: one request regardless of row count. Results are cached per domain for 24 hours by default, so a repeat sweep of last quarter's list is dramatically faster and returns cached: true with a single-digit response_ms.

Get Your API Key and Start Detecting Algolia

Start with /demo — no key, no signup, and it returns the exact response shape shown above, so you can build your jq filter before spending a request. When you are ready to scan a list, the free plan 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 plan uses the same endpoints and the same response shape, so the pipeline you write against the free plan runs unchanged when you scale it.

And the same call that finds Algolia also names the framework, the CMS, the hosting platform, the CDN, the ad pixels, and every other library on the page. One quota, one response, the whole stack.