Skip to content

Integration

How to build an in-house GEO dashboard with an API, and what it costs

A collector, four tables and a BI tool. For 150 prompts on five AI engines, the data line is $39 a month and everything under it fits in a free tier.

Four stacked flat layers in isometric view, pierced by a vertical line through a blue disc

SEO consultant, and more recently GEO, at MentionBox

An in-house GEO dashboard is four layers and one schedule: a collector that sends your prompt list to an AI visibility API, a table of raw answers keyed on prompt, engine, locale and run date, a metrics layer that computes visibility, share of voice, position, citation rate and sentiment, and a BI tool that reads the metrics layer rather than the API. For a brand team running 150 prompts on five engines four times a month, which is 3,000 AI answers, the only metered line is the collection: $39.00 a month with API for GEO, our editorial pick after hands-on testing by Mathias C., about $2.88 of scraping usage with DataForSEO for four of the five legs, or $30 on cloro's Lite plan. Everything under that line, storage, queries and the dashboard itself, fits inside a free tier.

This guide is written for a brand team that already has a warehouse and a BI tool, and has just been asked to put AI visibility next to the SEO and paid figures. It gives the four tables, the collector call with its real response shape, the SQL behind the first chart, the five cost lines of the build, and the point where a platform subscription beats the whole exercise. Prices and capabilities for the APIs come from each vendor's pricing page and reference, checked on October 23, 2026; infrastructure prices were read on November 13, 2026. MentionBox, which publishes this site, has a commercial link with API for GEO.

What an in-house GEO dashboard is made of

The pipeline is ordinary data engineering with one unusual input. Nothing in it is specific to AI search except the collector, and the collector is a vendor call rather than a scraping project, which is the change of the last two years.

  1. The prompt set, versioned in a table rather than edited in place. Our guide on building a prompt set for GEO covers how to choose the questions; the dashboard's requirement is narrower, that the list of prompts live under version control with an added date and a retirement date, so a trend line never measures your own edits.
  2. The collector, a scheduled job that sends the prompt set to an AI visibility API, polls for completion and writes the result. It is the only component that spends money per run.
  3. The raw store, one row per answer, with the answer text kept. This is the layer teams skip and regret.
  4. The metrics layer, SQL views over the raw store that produce the five figures a report quotes.
  5. The BI tool, reading the metrics layer. It never calls the vendor.

Our explainer on five ways to use an AI visibility API covers the other access patterns around the same key, an MCP server for ad hoc questions and webhooks for alerts. The dashboard is the pattern with a multiplication problem: point a BI tool at a vendor endpoint and every viewer who opens the report issues requests against a quota sized for your jobs.

The four tables everything else is built on

The schema below is the whole data model. It is deliberately boring, and the one design decision in it is the primary key of answers.

create table prompts (
  prompt_id    text primary key,
  prompt_text  text not null,
  prompt_type  text not null,   -- informational, commercial, comparison, branded, navigational
  locale       text not null,   -- 'US-en'
  cohort       text not null,   -- the release this prompt joined
  added_on     date not null,
  retired_on   date
);

create table answers (
  answer_id    text primary key,  -- hash of the five columns below
  prompt_id    text not null references prompts,
  engine       text not null,     -- chatgpt, perplexity, gemini, google-ai-mode, google-ai-overviews
  locale       text not null,
  run_date     date not null,
  run_index    int  not null,     -- 1..n when a prompt runs several times per cycle
  collected_at timestamp not null,
  vendor       text not null,     -- which API produced this row
  answer_text  text,
  unique (prompt_id, engine, locale, run_date, run_index)
);

create table mentions (
  answer_id    text not null references answers,
  entity       text not null,     -- normalised, aliases already collapsed
  entity_type  text not null,     -- brand, competitor, other
  position     int,               -- rank of the first mention inside the answer
  sentiment    numeric,           -- 0 to 100
  primary key (answer_id, entity)
);

create table citations (
  answer_id      text not null references answers,
  url            text not null,
  domain         text not null,
  category       text,            -- review, brand, editorial, forum, video
  mentions_brand boolean,
  primary key (answer_id, url)
);

Four properties of that schema earn their keep in the second quarter:

  • The unique key makes the collector idempotent. A retried job overwrites rather than double-counts, which is the difference between a chart that moved and a chart that was written twice.
  • run_index keeps repeat runs honest. One answer is one draw from a distribution, not a measurement. In an analysis we ran in October 2026, 8.7% of the brands ChatGPT named for a question came back in all five runs of that question, which is the argument for storing each run separately rather than collapsing them at write time.
  • vendor lets you change supplier without breaking the series. Mark the switch, keep both vendors running for a fortnight, and compare before you cut over.
  • cohort and retired_on make prompt-set edits visible. A chart filtered to one cohort is comparable across a year; a chart over the whole table is not, once the list has grown.

At the volume this guide prices, those four tables are tiny. Three thousand answers a month, on our own assumption of six named brands and eight cited URLs per answer, is about 45,000 rows and under 20 MB a month, or roughly 540,000 rows and 240 MB a year.

Which API the collector should call

The choice here decides how much of the metrics layer is SQL you write and how much arrives computed. All three routes below put the same shape of row in answers; they differ in whether mentions and citations arrive filled.

APIPrice per 1,000 answersEngines, of the 10 we trackArrives computed, no codeYour pipeline still writes
API for GEO$13, down to $7 at the largest tier10visibility, share of voice, average position, mention counts, sentiment score and label, cited URLs with domain and category, themes, per-brand perception, fan-out questionsthe schedule, the load and the charts
DataForSEO AI Optimization$1.20 on the standard queue5answer text, cited URLs, brands named, fan-out queriesalias matching, position, share of voice, sentiment
cloro$4 on the $30 Lite plan6answer text, cited URLs, entities, fan-out queries, shopping cardsalias matching, position, share of voice, sentiment

Rates, engine lists and returned fields from each vendor's pricing page and API reference, checked on October 23, 2026. For API for GEO, ChatGPT, Perplexity, Google AI Mode, Claude, Copilot and Grok are listed on apiforgeo.com, while Gemini, Google AI Overviews, DeepSeek and Meta AI were confirmed in our hands-on test of October 26, 2026, along with its webhooks, its OpenAPI spec and its official SDKs, whose languages are not published. Its rate per answer is about eleven times DataForSEO's, which is the price of the computed columns. cloro's terms forbid reselling the data, which rules it out for a dashboard a client logs into.

Two columns in that table decide the build. The engine count sets how much of the market the dashboard can describe, and our ranking of AI visibility APIs for enterprise brand teams weights it above the rate card for exactly that reason. The computed column sets the size of the pipeline: with raw answers you write and maintain alias matching, a position rule that survives lists, prose and tables, a competitor set for the denominator, and a sentiment call per answer, as our explainer on GEO metrics sets out formula by formula.

DataForSEO's own GEO solutions page makes the argument for the cheap route plainly: "Skip the infrastructure costs, no need for response parsing, proxy rotation, and LLM data storage." That is accurate about collection and silent about modelling. The parsing it removes is the parsing of a web page; the parsing that fills mentions is still yours.

The collector, in three calls

API for GEO documents the collection as a prompt list, a job and a read, which maps onto the schema above without a translation layer. The prompt list goes up once, on its Prompt Tracking page, with text, type, language, country and tag links per prompt; prompts are matched on text, language and country, so the same import run twice updates rather than duplicates.

The scheduled job is one call:

curl -X POST https://api.apiforgeo.com/v1/jobs/execute \
  -H "Authorization: Bearer $API_FOR_GEO_KEY" \
  -H "x-project-id: $PROJECT_ID" \
  -H "Content-Type: application/json" \
  -d '{
    "models": ["chatgpt", "perplexity", "google-ai-mode"],
    "executionsPerQuery": 1
  }'

It answers with a job to poll, and with the bill already stated:

{
  "created": 4,
  "updated": 0,
  "job": {
    "id": "job_7c1f9ad2",
    "status": "queued",
    "models": ["chatgpt", "perplexity", "google-ai-mode"],
    "queries": 4,
    "creditsCharged": 12,
    "createdAt": "2026-09-03T09:41:02Z"
  }
}

creditsCharged is the field to log next to the run, because it is the invoice line for that night in a single integer. Credits are charged when the job starts and reconciled on completion, and the page states that failed executions are refunded to the balance automatically.

The read is where the four tables get filled. POST /v1/queries/stats, scoped by model and country, returns per prompt a runs count, visibility and avgPosition, an entities[] array of every brand and competitor named with its own visibility and average position, a sources[] array of cited URLs carrying domain, category and mentionsBrand, and a responses[] array of raw answers with their model and execution time. The mapping is one to one: responses[] becomes answers, entities[] becomes mentions, sources[] becomes citations.

{
  "scope": { "models": ["chatgpt"], "country": "US" },
  "results": [
    {
      "id": "q_3f9a1c20",
      "text": "best project management tool for creative agencies",
      "runs": 90,
      "visibility": 64.8,
      "avgPosition": 1.8,
      "entities": [
        { "name": "Loopwork", "entityType": "brand", "visibility": 64.8, "avgPosition": 1.8 },
        { "name": "Cadence", "entityType": "competitor", "visibility": 52.2, "avgPosition": 2.4 }
      ],
      "sources": [
        { "url": "https://review-site.com/pm-tools", "domain": "review-site.com",
          "category": "review", "mentionsBrand": true }
      ],
      "lastExecutedAt": "2026-09-02T06:00:14Z"
    }
  ]
}

Example payload from the API for GEO Prompt Tracking page, which labels its sample figures as fictional data; the field names are the published contract.

Three published limits size the job. The pay-as-you-go plan allows 300 requests a minute and 10 concurrent executions, which is the ceiling on how wide a nightly fan-out can go, and keeps 24 months of history. Reads are not metered: the vendor's page states that "The AI Visibility API does not bill reads", qualified on the pricing page as unmetered within the rate limit, which is what makes a nightly backfill into your own warehouse cost nothing beyond the collection you already paid for.

On the scraping routes the collector is longer but the same shape. DataForSEO's AI Optimization API splits the work across endpoint families, with a Standard queue that posts tasks and reads them back later at the published rate and a Live method that costs more, plus postback_url and pingback_url for completion notices. One constraint belongs in the design: its LLM Mentions and AI Keyword Data endpoints are Live-only, so any history on those lives in your own tables or nowhere.

What the dashboard should show

Six figures cover what a brand team is asked for, and the first five are the ones every vendor platform also shows. The sixth is the one you only get by building it.

  1. Visibility per engine, per week. The share of answers that name the brand. Always per engine; one blended figure hides the engine where the brand is invisible.
  2. Share of voice against a fixed competitor set. Brand mentions divided by all brand mentions in the same answers, with the competitor list maintained by hand and dated when it changes.
  3. Average position. The rank of the first mention inside the answer, with a rule that holds for lists, prose and tables and does not change mid-year.
  4. Citation rate and the top cited domains. The share of answers citing one of your own pages, and the ranked list of everyone else's pages the engines reach for. Our guide on tracking AI citations of your pages covers the normalisation that makes that list stable.
  5. Sentiment. Scored per mention, not per answer, so that a positive paragraph about a competitor does not count in your favour.
  6. Collection health. Answers stored against answers expected, per engine, per run. Put it on the same page as the figures, not in a monitoring tool nobody opens.

One query produces the first two, with the sample-size rule built into the having clause:

select
  date_trunc('week', a.run_date)                              as week,
  a.engine,
  count(distinct a.answer_id)                                 as answers,
  100.0 * count(distinct case when m.entity = 'acme'
                              then a.answer_id end)
        / count(distinct a.answer_id)                         as visibility,
  100.0 * count(case when m.entity = 'acme' then 1 end)
        / nullif(count(m.entity), 0)                          as share_of_voice
from answers a
left join mentions m using (answer_id)
where a.locale = 'US-en'
  and a.run_date >= current_date - interval '180 days'
group by 1, 2
having count(distinct a.answer_id) >= 300
order by 1, 2;

The threshold is not decoration. cloro's published study on sample size, dated August 14, 2026, measured a mean overlap of 0.40 between the cited domains of two runs of the same prompt on the same model minutes apart, and puts about 300 answers in a period at roughly plus or minus 5 percentage points. A 150-prompt list on five engines produces 750 answers a cycle, so a weekly all-engine point clears the bar and a weekly per-engine point at 150 answers does not. Either widen the window to a month per engine, or say on the chart that the per-engine line is indicative.

What it costs, line by line

The workload priced below is one brand team: 150 prompts, five engines (ChatGPT, Perplexity, Gemini, Google AI Mode and Google AI Overviews), United States and English, four runs a month. That is 3,000 answers a month and 36,000 a year.

LayerWhat we priceMonthly cost at 3,000 answers
Collection, API for GEO3,000 credits at $0.013, metrics included$39.00
Collection, DataForSEO2,400 answers at $0.0012 on the standard queue, plus the Perplexity leg at costabout $2.88, after a $50 minimum payment
Collection, cloro13,200 credits of the 37,500 on the Lite plan$30, the plan floor
SchedulerGitHub Actions on a private repository, about 80 minutes a month at $0.006 a minute$0, inside the $12 of included compute on the Free plan
StorageBigQuery, under 20 MB a month$0, inside 10 GiB a month
Queriesa dashboard reading a 240 MB year of data$0, inside 1 TiB a month
BI toolData Studio, or Metabase Open Source self-hosted$0; $100 a month plus $6 per user on Metabase Starter
Build80 to 120 hours at $82 an hour, cloro's published estimate$6,600 to $9,900 once, plus about 3 hours a month

Our arithmetic on the rates each vendor publishes, checked on October 23, 2026 for the three APIs: 150 prompts × 5 engines × 4 runs = 3,000 answers. cloro's credit cost per engine comes from its providers page, 5 credits for ChatGPT and Google AI Overviews and 4 each for Perplexity, Gemini and Google AI Mode, which is 22 credits per prompt per cycle. Infrastructure rates read on November 13, 2026. The build estimate is cloro's, from its build versus buy post of April 14, 2026, updated November 9, 2026, which derives $82 an hour from a US median developer salary and a loaded-cost multiplier it describes as an assumption.

Three of those lines deserve their detail.

The infrastructure line really is near zero at this volume. Google Cloud's free tier page lists BigQuery at "1 TiB of querying per month" and "10 GiB of storage per month" per billing account, which holds several years of a 150-prompt programme and allows thousands of full scans of it. Google's own cost best practices add a detail worth knowing for a history table nobody edits: "If you have a table that is not modified for 90 consecutive days, the price of storage for that table automatically drops by 50 percent." If the warehouse has to be Postgres, Supabase's Pro plan is $25 a month with 8 GB of disk and no per-seat charge, and Neon publishes a worked example of about $15 a month on its Launch plan for a small, intermittently queried database, with storage at $0.35 per GB-month.

The BI line is a licensing question, not an infrastructure one. Google's Data Studio overview, which is where the lookerstudio.google.com address now resolves, says of the free version "It's easy and free", and its Pro documentation states that Pro licences are billed monthly per licence while "Users who only need to view reports... don't require a Pro license." Metabase's open-source edition is listed as "Free" with "Free unlimited users" and is self-hosted; its Starter plan is a $100 a month platform fee with the first five users included and $6 per user a month after that, and Pro is $575 a month with the first ten users included. Grafana Cloud is free for three active users and then a $19 monthly platform fee plus $8 per active user. Apache Superset is Apache 2.0 and publishes no price at all.

The scheduler line is smaller than the paperwork around it. GitHub's Actions billing documentation now states that "The included compute usage is expressed as a monetary amount, not a fixed number of minutes or other usage units", with $12 a month included on the Free plan, $18 on Team, and standard Linux runners at $0.006 a minute. A weekly collector that runs for twenty minutes spends about $0.48 a month, inside the included amount on any plan. Two of its published behaviours belong in the design: the shortest schedule interval is five minutes, and scheduled workflows in a public repository are disabled automatically after 60 days without activity.

When building beats buying a platform

The honest comparison is not a dashboard against a dashboard. A platform subscription buys the collector, the metrics layer, the charts and the maintenance of all three; the build buys the collector and leaves the rest with you, in exchange for your own schema, your own history and a per-answer rate instead of a plan floor.

cloro's published build-versus-buy post puts the crossover between $199 and $2,000 a month of platform spend, estimates the build at 80 to 120 hours plus about three hours a month, and concludes that "the common claim that building never pays back is only true at the bottom of the market". It is a vendor page arguing for its own API, and two of its own figures are worth checking before anyone quotes it in a business case: the maintenance hours it names are left out of its break-even table, and its body and its FAQ use two different hourly rates, $82 and $100, which produce payback periods that do not agree.

In our view the decision turns on three questions that have nothing to do with price:

  • Does the prompt set need segmenting the way your business is organised? Product line, market, funnel stage, distributor. A platform offers tags; a warehouse offers joins against the tables where those segments already live, which is the single best reason to build.
  • Do you already run a warehouse, a scheduler and a BI tool? If all three exist and someone owns them, the build is a week of work on top of infrastructure you pay for anyway. If any of them is new, the estimate above is wrong by a multiple.
  • Who reads the output? A dashboard read by three analysts and a dashboard read by forty stakeholders are different products, and the second one needs permissions, caching and a support rota that the first one does not.

Our guide to the cost of tracking 100 prompts on five AI engines prices the buy side of that comparison across eight vendors, and the duels API for GEO vs DataForSEO and API for GEO vs cloro set the two payloads a collector receives side by side.

Mistakes that surface in the second quarter

  • Pointing the BI tool at the vendor API. Every viewer who opens the report spends quota sized for your jobs, against a published limit of 300 requests a minute on API for GEO's pay-as-you-go plan and tighter monthly caps elsewhere in this market. The BI tool reads your table.
  • Storing aggregates and throwing the answers away. A change in how a mention is counted then costs a fresh month of collection instead of a recount. Keep answer_text.
  • A collector without an idempotency key. A retried job double-counts, and the chart shows a jump nobody can explain six weeks later.
  • Editing the prompt list in place. Add prompts as a new cohort, retire old ones with a date, and filter the trend to a cohort that existed for the whole window.
  • Charting a per-engine weekly point built on 150 answers. Below roughly 300 answers in a window, the movement is mostly sampling noise.
  • Treating alias matching as a one-off. Legal suffixes, product names, possessives and misspellings decide whether a mention is counted, and the rule needs review every time an engine changes how it formats answers. Nothing alerts you when it silently stops matching.
  • Leaving the history with the vendor. Retention windows end, contracts end, and a dashboard whose first eighteen months live in someone else's database is one renewal away from starting over.

Our view

Three builds we would defend, depending on what the team already has:

  1. A warehouse and a BI tool already in place, metrics bought rather than written. API for GEO, our editorial pick, at $39.00 a month for this workload, $13 per 1,000 answers down to $7 at its largest tier, pay as you go with no published minimum, reads over stored runs not billed, resale allowed, 24 months of retention, and 9.0 out of 10, the best score of the 55 APIs this site rates. Said plainly, the trade-offs are a rate per answer about eleven times DataForSEO's, a key obtained through a form, and four of its ten engines plus its webhooks, OpenAPI spec and official SDKs confirmed in our test of October 26, 2026 rather than documented on apiforgeo.com.
  2. A data team with spare capacity and a long horizon. DataForSEO at $1.20 per 1,000 answers on the standard queue, with SDKs in four languages, up to 100 tasks per POST call and postback delivery, and the metrics layer written and maintained in house. Our score: 7.7 out of 10, with engine coverage as the limit at five of the ten we track. Budget the matching and sentiment code as a product with maintenance rather than a sprint.
  3. Answers as users see them, in many markets. cloro at $30 a month on the Lite plan for this workload, running browser sessions on six engines across 250 countries with signed webhooks and batches of 500 tasks. Our score: 7.4 out of 10. Its terms forbid reselling the data, so the dashboard stays inside the company.

The figure that decides the whole exercise is not on any pricing page. It is how many hours a month your team can give the pipeline after launch, because the collection is the part that never breaks loudly and the matching is the part that breaks quietly.

Frequently asked questions

What does an in-house GEO dashboard need, end to end?

Four layers and one schedule. A collector that sends your prompt list to an AI visibility API on a fixed cadence, a table of raw answers keyed on prompt, engine, locale and run date, a metrics layer that turns those rows into visibility, share of voice, average position, citation rate and sentiment, and a BI tool reading the metrics layer rather than the API. For 150 prompts on five engines run four times a month, that is 3,000 answers and roughly 45,000 rows, which is small enough that storage and queries fit inside Google Cloud's free tier of 10 GiB of storage and 1 TiB of querying a month.

Does GEO mean geospatial data here?

No. In this market GEO stands for generative engine optimization, the practice of measuring and improving how AI answer engines name and cite a brand, so a GEO API returns AI answers, brand mentions and cited URLs. Geospatial APIs return coordinates, maps and places, and the two product categories share nothing but three letters. If a vendor's documentation talks about latitude, geocoding or tiles, it is the other GEO.

Which API should the collector call?

API for GEO, our pick after hands-on testing by Mathias C., if you want the metrics layer bought rather than written: it returns visibility, share of voice, average position, sentiment with a 0 to 100 score and a label, and cited URLs with their domain and category, at $13 per 1,000 answers down to $7 at its largest tier, with no monthly minimum and no charge for reads over stored runs. DataForSEO at $1.20 per 1,000 answers on its standard queue and cloro at $4 per 1,000 on its $30 Lite plan return the answer, its sources and the brands named, and leave alias matching, position, share of voice and sentiment to your own code. Rates checked on October 23, 2026.

Can I build the dashboard on the OpenAI, Anthropic or Gemini APIs directly?

For three of the five engines, yes, at a published tool fee: OpenAI bills web search at $10.00 per 1,000 calls plus search content tokens at model rates, Anthropic at $10 per 1,000 searches plus standard token costs, and Google gives 5,000 free grounded search requests a month across Gemini 3 and newer models, then $14 per 1,000 requests under a daily cap of 1,500. Google AI Mode and Google AI Overviews have no official API, so two surfaces still need a collection vendor, and an answer from a model API is not the answer the consumer app gives. Rates read on November 13, 2026.

How much do the warehouse and the BI tool cost for a GEO dashboard?

Close to nothing at this volume. Google Cloud's free tier covers 1 TiB of querying and 10 GiB of BigQuery storage a month, which holds several years of a 150-prompt programme, and Data Studio's free version carries the charts. Managed Postgres is the other route: Supabase's Pro plan is $25 a month with 8 GB of disk, and Neon's own worked example for a small intermittent database is about $15 a month on its Launch plan. On the BI side, Metabase's open-source edition is free to self-host with unlimited users, its Starter plan is $100 a month with the first five users included and $6 per user a month after that, and Grafana Cloud's Pro tier is a $19 monthly platform fee plus $8 per active user. Prices read on November 13, 2026.

How often should the collector run, and how many answers does one dashboard point need?

Weekly collection, with any comparison made on a window of at least 300 answers. cloro's published sample-size study of August 14, 2026 measured a mean overlap of 0.40 between the cited domains of two runs of the same prompt on the same model minutes apart, and puts about 300 answers in a period at roughly plus or minus 5 percentage points. A 150-prompt list on five engines produces 750 answers per cycle, so one weekly point clears that bar comfortably while a per-engine weekly point at 150 answers does not.