Try it
Run a live AI rank check
One real call, no signup and no key. The box runs one engine at a time — pick which.
Endpoints & Pricing
Two Ways to Buy an AI Rank Check
One engine, or the whole set in a single request. Both bill a flat rate per call: citation count, prompt style and a domain check never move it.
All four engines
- ChatGPT, Claude, Gemini and Perplexity in one request
- $10.00 an engine at Default, $0.50 an engine at Scale
- One blended score across the full 0–100 range
- Citations, positions and cited text, engine by engine
One engine
- One engine label per call: chatgpt, claude, gemini or perplexity
- Up to 10 cited sources, 15 with
prompt_type=deep - Position, URL, domain, title and cited text per source
- The score is capped at that engine's own share: 35, 25, 25 or 15
Four engines at $40.00 per 1,000 is $10.00 an engine, against $20.00 per 1,000 for a single one. At Scale the same comparison is $0.50 an engine against $1.00. Both discounts come from a single deposit — $100 for Growth, $500 for Scale — which is permanent and never downgrades. There is no monthly minimum anywhere in this pricing.
engines entirely and get them by default.
Every account starts with free API calls, and AI Ranking is free-eligible — it draws from that shared 10-call pool, then bills per call. A run in which every engine failed is refunded; a completed run is charged.
Supported engines
Four Engine Labels, One Response Shape
Each engine returns the same object under its own name, so one parser covers all of them. Each also has its own page and its own price comparison.
- Up to 10 citations per query (15 with
prompt_type=deep) - Cited URL, domain, page title and cited text
- Exact and subdomain matching on your domain
- Share of the blended score: 35
- Up to 10 citations per query (15 with
prompt_type=deep) - Cited URL, domain, page title and cited text
- Exact and subdomain matching on your domain
- Share of the blended score: 15
- Up to 10 citations per query (15 with
prompt_type=deep) - Cited URL, domain, page title and cited text
- Exact and subdomain matching on your domain
- Share of the blended score: 25
- Up to 10 citations per query (15 with
prompt_type=deep) - Cited URL, domain, page title and cited text
- Exact and subdomain matching on your domain
- Share of the blended score: 25
Every response carries a model field with that engine's public model label. Store it beside each result: when a label changes, a shift in your chart has an explanation sitting in your own data instead of looking like unexplained movement.
Quick Start
A Four-Engine Rank Check in One Request
The endpoint takes a keyword, an optional domain and an optional prompt style. Pass domain to get a visibility score — without it, visibility_score is null.
# All four engines. Omitting `engines` gives you all four by default. curl -G "https://apiserpent.com/api/ai/rank" \ --data-urlencode "q=best project management tools" \ -d "domain=example.com" \ -H "X-API-Key: YOUR_API_KEY" # One engine on its own, at the single-engine rate curl -G "https://apiserpent.com/api/ai/rank/chatgpt" \ --data-urlencode "q=best project management tools" \ -d "domain=example.com" -d "prompt_type=deep" \ -H "X-API-Key: YOUR_API_KEY"
# pip install requests import requests resp = requests.get( "https://apiserpent.com/api/ai/rank", params={"q": "best project management tools", "domain": "example.com"}, headers={"X-API-Key": "YOUR_API_KEY"}, timeout=120, ) data = resp.json() print("score:", data["aggregate"]["visibility_score"]) print("cited by:", data["aggregate"]["found_in"]) for name, row in data["results"].items(): print(name, row["target_found"], row["target_position"], row["total_citations"])
// Node 18+ — fetch is built in. Allow a generous timeout. const qs = new URLSearchParams({ q: 'best project management tools', domain: 'example.com' }); const res = await fetch('https://apiserpent.com/api/ai/rank?' + qs, { headers: { 'X-API-Key': process.env.SERPENT_KEY }, signal: AbortSignal.timeout(120000) }); const { results, aggregate } = await res.json(); console.log(aggregate.visibility_score, aggregate.found_in.join(', ')); console.log(results.chatgpt.target_position, results.claude.target_position);
{
"success": true,
"run_id": "550e8400-e29b-41d4-a716-446655440000",
"keyword": "best project management tools",
"target_domain": "example.com",
"results": {
"chatgpt": {
"llm": "chatgpt",
"model": "gpt-5.5",
"citations": [
{
"position": 1,
"url": "https://example.com/tools",
"title": "Top PM Tools 2026",
"cited_text": "...teams consistently rank it first [1]...",
"url_normalized": "example.com/tools",
"domain": "example.com"
}
],
"target_found": true,
"target_position": 1,
"target_match_type": "exact",
"target_matched_domain": "example.com",
"total_citations": 7,
"response_text": "For most teams the strongest options are ...",
"error": null
},
"claude": { "llm": "claude", "model": "claude-sonnet-4-6", "target_found": true, "target_position": 2, ... },
"gemini": { "llm": "gemini", "model": "gemini-3.1-pro", "target_found": false, "target_position": null, ... },
"perplexity": { "llm": "perplexity", "model": "sonar-pro", "target_found": true, "target_position": 3, ... }
},
"aggregate": {
"visibility_score": 65,
"found_in": ["chatgpt", "claude", "perplexity"],
"best_position": { "engine": "chatgpt", "position": 1 },
"all_domains_cited": ["asana.com", "example.com", "monday.com"],
"total_latency_ms": 21740
},
"meta": { "elapsed": "21802ms", "timestamp": "2026-09-08T10:00:00.000Z" }
}
An AI answer takes longer to arrive than a search page, so set a client timeout of at least 120 seconds rather than the 10 or 30 you would use elsewhere. Every key above is present on every response: an engine that cited nothing arrives with citations: [] and total_citations: 0, never with the field missing.
Data Fields
Every Field an AI Rank Call Returns
Typed JSON, not prose you have to run a regular expression over. Every key is present on every response, whatever the answer happened to contain.
Cited source fields
- results.<engine>.citations[].position
- results.<engine>.citations[].url
- results.<engine>.citations[].title
- results.<engine>.citations[].cited_text
- results.<engine>.citations[].url_normalized
- results.<engine>.citations[].domain
- results.<engine>.total_citations
Domain tracking fields
- target_domain
- results.<engine>.target_found
- results.<engine>.target_position
- results.<engine>.target_match_type
- results.<engine>.target_matched_domain
- aggregate.found_in
- aggregate.best_position
Answer and run fields
- run_id
- keyword
- results.<engine>.llm
- results.<engine>.model
- results.<engine>.response_text
- results.<engine>.error
- aggregate.visibility_score
- aggregate.all_domains_cited
- aggregate.total_latency_ms
- meta.elapsed
Request parameters
- q (the question, required)
- keyword (alias for q)
- domain (optional target)
- engines (comma-separated subset)
- prompt_type=standard (default)
- prompt_type=deep (up to 15 citations)
- prompt_type=brand (comparison form)
- X-API-Key (request header)
Visibility score
Where the 0–100 Number Comes From
Each engine carries a fixed share and the weighted results add up. The shares total 100, so the whole range only exists on a four-engine call.
Within an engine, position decides how much of that share you earn: a first-place citation counts for the whole of it and the value tapers with each place, down to a floor. Cited first by all four and the score reads 100. Cited first by one engine on a single-engine call and it reads that engine's ceiling — 35, 25, 25 or 15 — which is why a single-engine number should be read as a trend line rather than a grade.
Two things that surprise people. Citation counts ship in every response but do not move the score — being cited twice by one engine is not worth more than being cited once. And the score is null unless you pass a domain to match: with no domain there is nothing to score, and the call still returns every citation list in full.
Why AI visibility data
What AI visibility data is, and why teams buy it
There is no results page to read a position off. The evidence is the list of sources an answer names, which is what this endpoint returns.
Four engines is the point, and nobody else sells four
Every vendor that sells an AI answer per call is missing at least one engine. Bright Data’s Claude scraper page returns an HTTP 404. Oxylabs lists ChatGPT, Gemini and Perplexity targets only, and its Claude URL is a 404 too. DataForSEO’s LLM Scraper page states that only ChatGPT and Gemini are supported, and it does not cover Perplexity at all.
Re-checked 2026-09-10, and each one is a single click to verify. That is a statement about what is on sale, not about quality.
Everyone else sells a seat, not an endpoint
Profound, Peec, Otterly, Scrunch, Athena, Semrush, Ahrefs Brand Radar, Rankability and LLM Pulse all sell a monthly dashboard rather than an API, and most keep API access on their top tier. Where a per-response figure can be computed from a vendor’s own page, it is far above a per-call rate: Profound at $44.33 per 1,000 responses and Athena at $81.94.
A dashboard is a fine product. It is not something you can put behind a client report that regenerates itself every Monday.
One score is only comparable across engines
A number from one engine tells you about that engine. The blended score exists so that a single figure can be charted week over week for the same keyword, and so two brands can be compared on the same axis instead of on four separate ones.
The shares are fixed and published above, so the number is reproducible: the same citation lists always produce the same score.
One parser, four engines, no per-engine branch
The combined call nests the same object under each engine name, and the single-engine call returns that same object under just one. Adding an engine to an existing integration is a change to the query string, not to your parsing code.
Subdomain matches are resolved for you: ask for example.com, get docs.example.com cited, and target_match_type comes back as subdomain with the matched host beside it.
Price comparison
What a Four-Engine Check Costs Elsewhere
No vendor publishes a flat per-call rate covering all four engines, so this compares our combined call against each vendor’s cheapest published per-call rate.
| Provider | Cost per 1,000 | What one call buys | What the lowest rate requires | Free tier |
|---|---|---|---|---|
| Serpent (ours) | $2.00 | Four engine answers and a blended score | A one-time $500 deposit, permanent. No monthly plan | Free to start |
| Oxylabs | $0.95 | One AI answer, JavaScript rendering on | A custom quote. Its cheapest rate on a plan with a published price is $1.00 on $999 a month | 2,000 results |
| SearchApi.io | $1.00 | One AI answer | $5,000 a month | 100 requests |
| ScrapingBee | $1.12 | One AI answer, 15 credits | $599 a month. Its entry plan is $3.80 per 1,000 | 1,000 credits |
| DataForSEO LLM Scraper | $1.20 | One AI results page, queued up to 45 minutes | A $50 minimum deposit. Its live rate is $4.00 | None |
| cloro.dev | $1.22 | One AI answer, 4 credits | $5,000 a month. ChatGPT is 7 credits, $2.14 | 500 credits a month |
| Bright Data | $1.30 | One AI record | $499 a month. Pay-as-you-go is $1.50 | 5,000 records a month |
| Profound | $44.33 | One response, inside a dashboard | Annual billing. API access is Enterprise-only | None |
| Athena | $81.94 | One response, inside a dashboard | $295 a month | None |
The Oxylabs, DataForSEO, ScrapingBee and SearchApi.io rows were re-read from those pages on 2026-09-10; the rest were read on 2026-09-08 and are unchanged. “Cost per 1,000” is each vendor’s lowest published rate, which is why the requirement column matters: most of these need a recurring plan, and ours needs one deposit. Oxylabs shows its plan tiles in a rotating carousel, so a single page view shows only part of the ladder; $0.95 is its cheapest published with-JavaScript rate and it sits on a quote-only tier. Peec and Ahrefs Brand Radar are left out because their published figures could not be read consistently from their own pricing pages. Serpstack and Serply are left out because neither sells an AI product at all.
The honest loss, per engine. Measured one engine at a time, we are not the cheapest at Default or at Growth: all six flat-rate vendors above publish a lowest rate under our $2.00 Growth rate, and every one of them is far under $20.00. At Scale our $1.00 is matched by SearchApi.io and undercut by Oxylabs — and both carry a condition ours does not. SearchApi.io’s $1.00 needs $5,000 a month; Oxylabs’ $0.95 is a custom quote, and its cheapest rate on a plan with a published price is $1.00 on $999 a month. Ours is unlocked by one $500 deposit and is never withdrawn.
The comparison that is not a margin. Nobody on this table sells four engines in one call, so a like-for-like four-engine setup means four vendors or four separate calls. And the cheap per-call rates here do not cover the whole set: DataForSEO’s $1.20 has no Perplexity equivalent and no Claude equivalent, and Oxylabs’ $0.95 has no Claude equivalent, so the cheapest numbers on this table simply do not exist for half of it.
The engines’ own APIs are a different purchase. OpenAI’s own developer API charges $10.00 per 1,000 web searches plus token costs; Anthropic’s is $10.00 per 1,000 searches plus token costs; Google publishes 5,000 free requests a month on its own developer API and $14.00 per 1,000 requests plus token costs past that; Perplexity’s Sonar bills a per-request fee that changes with context size, plus per-token charges. Four accounts, four bills, and what comes back is prose — not a citation list with positions, a domain match and a score.
Use cases
What Teams Use a Four-Engine Check For
Four jobs this endpoint gets bought for, and the field each one reads.
An AI column in a rank-tracking report
Store aggregate.visibility_score per keyword per week beside your existing Google positions. Two numbers on one date is enough to show a client where organic and AI visibility have come apart.
Keep the engine set fixed across a series. A score from four engines and a score from two are not on the same axis.
Share of citations against competitors
aggregate.all_domains_cited returns every domain the four engines named for that question, whatever domain you tracked. Counting how often each rival appears across a keyword list is a share-of-voice measure that no rank report contains.
Run the same list with a competitor in domain to get their position and score directly.
Proving a content change worked
Record run_id, the date and the citation lists before you publish a change, then run the same keyword afterwards. The two sets are the before and the after, held in your own storage rather than a vendor’s.
cited_text shows the passage each source was named for, so you can see which claim was picked up, not just that the page was mentioned.
Auditing a topic rather than a keyword
prompt_type=deep raises the citation ceiling from 10 to 15 and asks for a fuller treatment, which surfaces sources a short answer never reaches. prompt_type=brand asks in comparison form.
Whichever style you pick, keep it fixed inside a series, or the numbers stop being comparable with each other.
# One row per keyword per run: the score, which engines cited you, and every # domain the four engines named. The citation list is the evidence you keep. import csv, datetime, requests KEYWORDS = ["best project management tools", "cheapest serp api"] TODAY = datetime.date.today().isoformat() with open("ai-visibility.csv", "a", newline="") as fh: out = csv.writer(fh) for kw in KEYWORDS: r = requests.get( "https://apiserpent.com/api/ai/rank", params={"q": kw, "domain": "example.com"}, headers={"X-API-Key": "YOUR_API_KEY"}, timeout=120, ) agg = r.json()["aggregate"] out.writerow([ TODAY, kw, agg["visibility_score"], "|".join(agg["found_in"]), "|".join(agg["all_domains_cited"]), ])
FAQ
AI Rank API Questions
GET /api/ai/rank returns all four in one request, nested under their own engine names in the same object shape. GET /api/ai/rank/<engine> returns one of them on its own. Every engine carries the same keys, so one parser covers all four and adding an engine is a change to the URL, not to your code.
engines=chatgpt,claude,gemini,perplexity, or simply omit the parameter, which defaults to all four.
null unless you pass a domain to match.
prompt_type=deep. Neither is a promise — a narrow question routinely produces fewer, which is what total_citations is for. If nothing was cited, citations arrives as an empty array rather than disappearing from the response, so your parser never has to test for a missing key.
citations array and its error field set, and every other engine ships as normal — the response shape never varies, so you are never handed a partial object with keys missing. Only when every engine in a run failed is the call treated as undelivered, and that run is refunded.
aggregate.all_domains_cited on every call, whatever domain you tracked — the full set of domains cited across the four engines for that question, which is the share-of-citation picture rather than a single-domain check.
Start tracking your AI visibility
free API calls, no card and no subscription. Four engines in one request from $2.00 per 1,000 queries.
Try for Free
