API Platform · v1

One API for AI search visibility

Track how ChatGPT, Perplexity, Claude, Gemini, Grok, and Google AI Overviews recommend your brand. Programmatically. Pipe the data into your dashboard, your warehouse, or your customers' product, all from a single REST contract.

Read the docs Get an API key
OpenAPI 3.1 spec
Scoped bearer tokens
Idempotent writes
Brand-restricted keys
Versioned forever
POST /v1/brands Live 
curl https://api.rankprompt.com/v1/brands \
  -H "Authorization: Bearer $RANKPROMPT_API_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{
        "name": "Acme Cloud",
        "website": "https://acme.com",
        "language": "en",
        "country": "US",
        "categories": ["devtools", "infra"]
      }'

# 201 Created
{
  "id": "brnd_01JFR3K9...",
  "name": "Acme Cloud",
  "website": "https://acme.com",
  "created_at": "2026-04-20T14:02:11Z"
}
Why an API

Skip the scraping, the spreadsheets, and the six different SDKs

Tracking AI visibility yourself means juggling six paid APIs, scoring mentions, dedup-ing citations, and building a UI on top. Rank Prompt collapses all of that into one normalized contract, so you ship the dashboard and skip the data layer.

Your stack

Backend & workers
Dashboard & CRM
Warehouse & BI

Rank Prompt Public API

/v1

Scoped keys
Idempotent writes
Quota headers
Structured errors
OpenAPI 3.1
Brand-pinned keys

6 AI platforms

ChatGPT
Perplexity
AI Overviews
Claude
Gemini
Grok

One contract, one bill, one schema. Six AI engines, normalized into the same visibility_score and mention_count primitives the dashboard already uses.

What you can build

Every feature in the platform, available as an API

The same building blocks that power the Rank Prompt dashboard. Brand management ships today; the rest is rolling out under /v1 over the coming months. Every endpoint follows the same auth, error, and idempotency contract from day one.

Available

Brand management

Programmatically onboard brands, update categories, languages, aliases, and competitors. Perfect for agencies provisioning new clients without touching the dashboard.

Available

AI visibility reports

Run prompts across ChatGPT, Perplexity, AI Overviews, Claude, Gemini, and Grok. Pull mentions, ranking position, and visibility score into your stack.

Available

Citation & source tracking

Discover the sources AI assistants cite when recommending brands in your space, with the Rank Prompt Score so you only outreach to reachable targets.

Available

Scheduled reports

Cron-style report definitions: weekly competitor snapshots, monthly visibility deltas, anomaly alerts. Delivered as JSON or shareable PDFs.

Coming soon

Brand audit & perception

Automated snapshots of how AI describes your brand: positioning, claims, comparisons against competitors, and the weak spots to fix first.

Coming soon

AI-optimized content

Generate articles, comparisons, ranked lists, and FAQ blocks built to be cited by AI assistants. Trigger and ship the full content lifecycle from your CMS.

Coming soon

Technical SEO audits

Trigger Lighthouse-grade crawls, Core Web Vitals checks, and AI-readability scans. Stream issues into your existing engineering ticket queue.

Coming soon

Outreach & backlinks

Surface high-value outreach targets, push prospects into your CRM, and trigger AI-personalized email campaigns with verified contact data.

Coming soon

Webhooks & events

Real-time push for report completion, ranking changes, and quota thresholds. Signed payloads, replay-friendly delivery, full event history.

Track release dates in the changelog or browse the live surface in the API reference.

How it works

From signup to first call in under 10 minutes

No oddly-named handshakes, no SDK install dance. A bearer token, a curl command, and you're moving data.

01

Mint a scoped API key

Subscribe to a paid plan, open the Developers page in your workspace, pick the scopes you need, and (optionally) pin the key to a single brand for white-label work.

02

Call /v1 from your backend

Send a bearer token, follow the OpenAPI spec. Every metered response carries quota headers so you can pace work; idempotency keys make every POST safe to retry.

03

Stream insights into your stack

Pipe results into your dashboard, warehouse, CRM, or Slack. Webhooks are on the roadmap; today, polling `/v1/me/quota` (free) and report status endpoints scales perfectly.

See the full quickstart in the docs
Built for production

A contract you can depend on

Every primitive you'd expect from a serious payments or analytics API. Boring, predictable, and well-documented; not flashy and brittle.

OpenAPI 3.1 spec

Spec-first design. Generate an idiomatic client in any language with openapi-generator, Stainless, Fern, or Speakeasy. The whole surface is browseable in the hosted reference.

Scoped & brand-restricted keys

Mint keys with the minimum surface area required: read-only, write-only, per-resource, or pinned to a single brand for white-label work. Keys are shown once, stored hashed.

Idempotent writes

Every POST accepts an `Idempotency-Key`. Network retries, queue redelivery, and worker restarts are safe by default.

Predictable rate limits

120 requests per minute per key plus a monthly quota. Every metered response carries `X-RP-Quota-*` headers; throttled calls return `Retry-After`. No surprise back-pressure.

Structured errors

Stable `error.code` values from a published catalog, machine-readable details, and a `request_id` echoed in every response for end-to-end tracing in support tickets.

Versioned forever

The /v1 contract is additive: new fields and endpoints only. When a breaking change is needed we ship /v2 alongside, with long deprecation windows announced via `Sunset` headers.

Use cases

Ship in days, not quarters

The four shapes most teams take when they integrate. Pick the one closest to yours; mix and match the rest.

Agencies

White-label AI visibility dashboards

Spin up a per-client dashboard in your own product. One brand-pinned API key per client, your branding, your billing, our data layer.

BI & analytics

Pipe AI metrics into your warehouse

Schedule nightly pulls of ranking, citation, and visibility data into Snowflake, BigQuery, or Looker. Track AI presence right next to organic traffic.

Ops & alerting

Trigger Slack and PagerDuty when rankings move

Subscribe to events for visibility drops, lost citations, or new competitor mentions. Page the team only when it actually matters.

Embedded SaaS

Ship AI insights inside your product

Surface AI mention scores and citation graphs inside your own app. Customers see their visibility without ever leaving your product.

Pricing

Two meters. No surprises.

Every Rank Prompt plan includes API access. Most CRUD calls cost a single request unit and draw from your monthly allowance. Heavy LLM operations (visibility reports, content generation, audits) consume credits from the same pool the in-app product uses, so you never pay twice for the same work.

See plans Per-endpoint cost map
0 request units

/v1/me and /v1/me/quota: free to poll, anytime.

1 request unit

Typical CRUD call (list brands, fetch a brand, mint a key).

120 req / minute

Per-key burst limit. Quota and `Retry-After` exposed on every response.

FAQ

Developer questions

Everything teams ask before they integrate. Email us if your question isn't covered.

What can I build with the Rank Prompt API today?
Brand management (create, list, retrieve, update, delete), AI visibility reports across the six major LLM platforms, citation & source tracking with the Rank Prompt Score, scheduled reports, plus the account endpoints (`/v1/me`, `/v1/me/quota`). Brand audits, AI-optimized content generation, technical SEO audits, outreach, and webhooks are on the public roadmap and ship under the same /v1 contract; subscribe to the changelog to track release dates. The eventual surface mirrors the dashboard 1:1.
How is the API priced?
Two independent meters. Request units cover the per-key rate limit (120/min) and the monthly quota included with your plan. Credits are only consumed by endpoints that hit a paid LLM or third-party search backend, and they come from the same credit pool you already use inside the dashboard, so you never pay twice for the same work. The full per-endpoint cost map lives in the developer docs.
Are there official client libraries?
Not yet. The API ships with an OpenAPI 3.1 spec, so you can generate idiomatic clients in any language using openapi-generator, oazapfts, hey-api, Stainless, Speakeasy, or Fern. The docs include curl, JavaScript (fetch), and Python (httpx) examples for every endpoint. First-party TypeScript and Python SDKs are on the roadmap.
How do you handle versioning and breaking changes?
The /v1 contract is additive. We only add fields and endpoints; we never silently remove or rename them. When a breaking change is unavoidable, we ship /v2 alongside /v1 with a long deprecation window, and we announce the sunset of any endpoint via the standard `Sunset` HTTP header well in advance.
Do you support webhooks?
Webhooks for events like `report.completed`, `ranking.changed`, and `quota.threshold` are on the public roadmap and ship alongside the report endpoints. Until they land, the recommended pattern is to poll `GET /v1/me/quota` (free, zero request units) and the report status endpoints from your worker.
How do I get an API key?
Subscribe to a paid Rank Prompt plan, then visit the Developers page in your workspace to mint a key. Each key carries scoped permissions (e.g. `read:brands`, `write:brands`) and an optional brand restriction for white-label use. Keys are prefixed with `rp_live_`, are shown once at creation, and stored hashed in the database.
What are the rate limits?
A per-key burst limit of 120 requests per rolling minute is applied to every API key, regardless of plan. On top of that, your plan grants a monthly request-unit quota. Every metered response includes `X-RP-Quota-Limit`, `X-RP-Quota-Used`, `X-RP-Quota-Remaining`, and `X-RP-Quota-Reset` so you can pace work without polling. Throttled calls return a 429 with `Retry-After`.
Is there a sandbox or test environment?
The `GET /v1/me` and `GET /v1/me/quota` endpoints cost 0 request units and never count against your quota, so you can validate keys, scopes, and request signing without burning budget. For full end-to-end tests, mint a separate key with limited scopes and exercise it against a test brand.
Can I issue per-brand keys for my clients?
Yes. Optionally bind a key to a single brand at creation time (`allowed_brand_id`). The API will refuse any request whose target brand does not match, even if the calling key carries `write:all`. This lets agencies and platforms issue per-brand keys to clients without spinning up a new Rank Prompt workspace.
How is the API secured?
Bearer-token authentication over TLS, scoped per-resource. Browser CORS calls are blocked at the edge: the API is server-to-server only. Keys are stored hashed and we submit the `rp_live_` prefix to GitHub secret scanning so leaked keys are caught automatically. The API runs on the same hardened infrastructure as the rest of the Rank Prompt platform, with EU/US data residency options.

Still have questions? Contact our team

Public API v1

Start building today

Read the quickstart, mint your first API key, and ship a working integration before lunch.

Read the docs Get an API key