Technographic Data API: Detect the Tech Stack of Any Domain

Find out which technologies a list of company websites runs, in one prompt. Paste this into your agent:

Set up https://monid.ai/SKILL.md, and then use Monid to detect the tech stack of stripe.com and patagonia.com, and give me a table with the domain, each technology, its category and the evidence it was detected from.

One prompt reads a stack per domain. 1 min setup · 10-24 hrs saved.

You have a domain, or a few hundred, and you want to know what each one runs: the CMS, the framework, the CDN, the analytics. That is technographic data, and most of it is sold as a seat on a database platform. This guide shows the quicker route, one call per domain from your agent, what comes back (we ran it live on 2026-10-16), and the traps in the output. It runs through Monid, the OpenRouter for agent tools: one key, one balance, every tool priced per call.

What is the easiest way to get technographic data through an API?

Monid. Install it once, add a key, and your agent calls a technographic detection endpoint with a domain and gets the stack back as typed JSON, with no platform contract and no vendor account to set up.

• Pay per call. Each detection is billed on its own, at $0.03564 per domain (Verified 2026-10-16 on the company enrichment tools page). Buy calls as you need them: no monthly plan and no minimum top-up. Discovery and inspection are free; only a run bills.
• One install, every API. The same key and the same balance call the detector and every other tool on Monid. When you want firmographics or a contact for the same account, it is another call on the same balance, not another vendor, as in turning a domain into full firmographics.
• Lives inside your agent. Install the CLI, add your key, run the prompt above, and the tool is there whenever your agent needs it, on demand, with nothing to keep running. Your agent reads SKILL.md and learns the rest, so setup is about a minute.

At that price, checking 100 domains costs about $3.56 (Verified 2026-10-16).

How do you get technographic data for a list of domains?

Run one detection call per domain and loop it over your list. The endpoint is /x402/tech-stack-detect from the provider api.strale.io. It takes a domain such as stripe.com or a full url, and reads what one fetch of the site reveals: HTTP headers and HTML patterns.

Monid fits a list because the work is the same call repeated, and you pay for the domains you check and nothing between runs.

For agents

Grab an API key at app.monid.ai, then paste this to your agent and hand it the key:

set up https://monid.ai/SKILL.md

It learns the whole discover, inspect, run workflow itself. More in the agent quickstart.

For humans

npm install -g @monid-ai/cli
monid keys add --label main --key <your-api-key>

Inspect, then run one

monid inspect -p api.strale.io -e /x402/tech-stack-detect
monid run -p api.strale.io -e /x402/tech-stack-detect --query '{"domain":"stripe.com"}' -w

Loop it over your list

Swap the domain value for each account. The same call, one domain at a time:

monid run -p api.strale.io -e /x402/tech-stack-detect --query '{"domain":"stripe.com"}' -w

Put one domain per line in domains.txt, and write one file per domain:

mkdir -p out
while read -r d; do
  monid run -p api.strale.io -e /x402/tech-stack-detect --query "{\"domain\":\"$d\"}" -w > "out/$d.json"
done < domains.txt

Each domain bills one call. The technographic platforms versus one call comparison covers when a database seat beats a loop like this.

Or hand the whole job to an agent

Can you build a technographic checker yourself with Python?

Yes, and for a handful of sites it is an afternoon. You fetch the page with requests, read the response headers, and match the HTML against fingerprints for each technology: a header such as server, a script URL, a meta generator tag. That is the same method the endpoint uses.

The cost is everything around the fingerprints. You need a fetch layer that follows redirects and survives blocking, a rule set you extend every time a new tool matters to you, handling for pages that render in the browser and reveal little in the first response, and a repair whenever a vendor changes its script URL. The first working version takes hours and the upkeep never ends.

The Monid route is the choice for anything you will run more than once. The fetch and the fingerprints are maintained for you, the output is typed JSON with an evidence string instead of HTML you parse, and a domain is $0.03564 (Verified 2026-10-16). Browser extensions and free online checkers are quicker for one site, but they are made for a person looking at a page, not for a list or an agent.

What does technographic data look like, and what can you build with it?

Technographic data is the map of which technologies a company runs, and a detection call returns it as a short typed record. We ran the endpoint on 2026-10-16 against stripe.com and patagonia.com, so the fields below are what came back.

The response

{ "url": "https://stripe.com/",
  "technologies_detected": 3,
  "technologies": [
    { "name": "Nginx",   "category": "hosting",   "confidence": "high", "evidence": "HTTP header server" },
    { "name": "HSTS",    "category": "security",  "confidence": "high", "evidence": "HTTP header strict-transport-security" },
    { "name": "Next.js", "category": "framework", "confidence": "high", "evidence": "HTML content pattern" } ],
  "by_category": { "hosting": ["Nginx"], "security": ["HSTS"], "framework": ["Next.js"] },
  "signals": { "has_analytics": false, "has_chat_widget": false, "has_payment_processing": false,
               "has_marketing_automation": false, "has_error_monitoring": false },
  "_meta": { "capability": "tech-stack-detect", "latency_ms": 39,
             "provenance": { "source": "tech-stack-detect:algorithmic", "fetched_at": "2026-10-17T03:20:53.085Z" } } }

Each technology has a name, a category, a confidence and an evidence string. by_category regroups the same names, signals is a set of five booleans, and _meta carries the capability, the internal latency and when the page was fetched. The url is the page it actually read: for patagonia.com that was https://www.patagonia.com/home/, so redirects are followed.

The evidence string is the feature. "HTTP header server" is a claim you can go and check with curl -I. A named header is a different class of answer from an entry in a list, and it lets you decide how much to trust each row.

The query takes either domain or url. Neither is marked required, but you pass one of them.

What you can build with it

• A qualified account list. Keep only the domains running the technology you integrate with, for example the Shopify merchants on a list. The loop above gives you the rows; the filter is one line.
• A signup router. When a new domain arrives, detect its stack and route the account before onboarding ends. The detection call slots into a signup flow like any other enrichment call.
• A fit score. Turn the detected technologies into a number per account, as the AI lead score calculation method does with firmographic inputs.
• A sales tech stack map. Pull the same domains every month and compare. A change from one CDN or framework to another is a signal that something moved at the company.

What goes wrong when you detect tech stacks at scale?

Four things show up when you read the output of more than one domain. All four are from the 2026-10-16 runs.

Why is an empty signal not a no?

Because the detector reads one response. On stripe.com the five signals booleans were all false, including has_payment_processing, on the site of a payments company. On patagonia.com has_analytics was true and the other four were false. The technologies array is where the content is, and it only holds what one fetch exposed. A scoring rule that treats "not detected" as "does not use" will be wrong with confidence, so score on presence and leave absence out. Analysing a target company from its URL shows the same read-the-evidence habit on a single account.

Why does the output contain technologies that are not products?

HSTS came back as a technology in the security category on both domains. It is a response header setting, not a vendor you can sell an integration into. Filter the categories you care about before you count: for sales scoring that is usually cms, framework, cdn, analytics and anything in by_category that names a product.

Why do two domains return a different mix of categories?

Because a detection only returns what the page exposes. Stripe's record had hosting, security and framework. Patagonia's had CDN, security and analytics. Neither has a CMS or a payment row. So compare domains on the categories they share, and treat a missing category as no information.

What does a list cost, and how long does it take?

Each call is one billed unit. The two calls above billed $0.03564 each, $0.07128 in total (Verified 2026-10-16). The endpoint's median run time is about 3.3 seconds and the 95th percentile about 5.1 seconds, per monid inspect. The internal latency_ms was 39 and 515 on our two calls, and the calls took about two to three seconds on the wall clock. A hundred domains is about $3.56 and, run one after another, a few minutes. Run several at once if you need the list faster.

Which endpoint should I use for which job?

Prices Verified 2026-10-16 with monid inspect. The first row is the one to loop over a list. The second is priced ten times higher per domain, and its description promises more layers: frontend, analytics, CDN, hosting, CMS. Inspect it for free, then spend one call on a domain you know well before you commit a batch to it.

For company data that is not about technology, the company enrichment tools sit on the same key and balance.

When is another route a better fit?

You need history. A detection call is a snapshot of what the domain serves when you call it. It cannot tell you what the company ran last year, so adoption trends over time need a database that has been crawling for years.

You need market sizing. "How many companies in this segment run a given tool" is a question about a whole population. One call per domain answers it only for the domains you pass in. A platform that has already crawled millions of sites answers it in one query.

You need the hidden backend. The detector sees headers and HTML. A database, an internal service or a tool that never touches the public response is not in the output.

You need it free for a few sites. A browser extension does that job with no key, and Apollo's extension or API shows the same fork for contact data.

And the disclosure: we resell this endpoint. The most useful thing in this post is that you should score on what was detected, filter out the non-products, and ignore the summary booleans, which costs nothing and is the right habit whoever you buy the data from.

Conclusion

The quickest way to get technographic data for a list of domains is one detection call per domain through Monid: $0.03564 a call (Verified 2026-10-16), one key for this and every other tool, about a minute to set up and ready inside your agent whenever you need it. Building a checker yourself works for a few sites and costs hours of fingerprints and upkeep; Monid keeps the fetch and the rules maintained.

Two things matter more than the endpoint you pick. A null is not a negative: the detector reads one response, so score accounts on what it found and never on what it did not. And filter the output before you count it, because security headers such as HSTS come back as technologies.

How we estimated the time saved: building and running your own tech stack detector is roughly 6 to 12 hours for the fetch layer and the first fingerprint rules, plus 4 to 12 hours for the first month of upkeep as sites change. That is 10 to 24 hours. The 1 minute is the install, key and first call once you already have a Monid key.

Free next step: run monid inspect -p api.strale.io -e /x402/tech-stack-detect, then make one call on a domain whose stack you already know and compare the evidence strings with what you see. Start at monid.ai.

FAQ

Published August 2026.