2026-09-18, Analytics · Fundamentals

AI monitoring cost planning: estimate the bill up front

Every request has a fixed dollar price, so a monitoring bill can be computed before the first run. Fix prompts, markets, engines, runs per month and add-ons, multiply, and you have the monthly cost and the balance to keep topped up.

Definitions

• Price: every request is charged in dollars from your prepaid balance. Prices per request come from the price table, do not depend on answer length, and drop on larger tiers (reached by 30-day spend). The figures here are Starter prices, what every account pays first.
• Run: one collected answer for one prompt, one market and one engine.
• Add-on: an include option that raises the price of a run.

The formula

monthly cost = Σ over engines ( prompts × markets × runs per month × (base + add-ons) )

Each factor is a decision:

• Prompts. A focused set that represents the category beats a large redundant one. See prompt set design.
• Markets. Each country multiplies everything. ChatGPT, Gemini, AI Mode and Google Search answer from 213 countries; Copilot, Perplexity and Grok take any country, and Google News the 71 countries with a Google News edition. Gemini also takes a US state, each one its own market. Add a market only when answers there drive a separate decision; state-level answers covers when that is true.
• Engines. Choose the assistants and search surfaces your buyers use to research your category. If you do not know, run the short pilot described below.
• Runs per month. Set by how fast you need to detect a change and how noisy the metric is. Monitoring cadence and answer volatility cover both.
• Price per run. See the table below.

Price per run

Prices per request at the Starter tier:

POST /v1/monitor/google/goto, which resolves a redirectLink, is free.

Two worked prices to check your reading of the table: ChatGPT with shopping is $0.0006, because the flag adds nothing; a Google News task with pages: 3 is $0.0002, because extra pages are free. More detail is on /docs/credits.

Balance and tiers

There is no plan or subscription. You top up a USD balance from $1.00 in the dashboard, optionally with auto top-up, and each request is charged from it; a new account starts with 100 free requests on any engine. The more you spend over 30 days, the cheaper each request: Growth from $95.00, Pro from $240, Business from $475, Scale from $950, Max from $1,900. ChatGPT, for example, runs $0.42–$0.60 per 1,000 across the tiers. Current prices for every tier are on /pricing.

A worked example

A category tracker for a B2B software company:

• 80 prompts (40 category, 25 competitor comparison, 15 brand)
• 1 market (US)
• ChatGPT and Gemini daily (30 runs in a 30-day month)
• Google News weekly for 20 brand and competitor queries (counted as 4 runs a month), first page only
• No add-ons

ChatGPT:      80 × 30 × $0.0006 = $1.44
Gemini:       80 × 30 × $0.0006 = $1.44
AI engines:   80 × 30 × ($0.0006 + $0.0006) = $2.88
Google News:  20 × 4 × $0.0002 = $0.016
total = $2.90 / month

That is about $2.90 a month at Starter prices.

A calendar month can contain five weekly runs instead of four. At five, Google News costs 20 × 5 × $0.0002 = $0.02, and the total becomes $2.90.

Add-ons that cost nothing

Google News pages: 3 and ChatGPT’s shopping and rawResponse flags are free, so they leave the total at $2.90.

Sync versus async

Synchronous calls keep a connection open for up to five minutes each; async tasks wait in the queue and report back. Scheduled monitoring belongs in async batches with webhooks; keep synchronous calls for interactive use. The trade-offs are in sync, async and webhooks.

A method for sizing a budget

1. List the decisions the data will drive (content priorities, client reporting, alerts). Each engine, market and add-on must serve one.
2. Draft the dimensions: prompts per group, markets, engines, cadence per group.
3. Price each engine line with base + add-ons.
4. Sum, and add the five-weekly-runs month if you have weekly lines.
5. Top up for the total with headroom for retries of your own design, ad-hoc checks and pilots, or turn on auto top-up.
6. Run a pilot at a fraction of the size for two weeks and compare credits.creditsCharged against the estimate.
7. Adjust multipliers as well as cadence, and re-price.

Checking the estimate in code

Every task response carries credits.creditsToCharge, the maximum reserved for that task, and a finished task carries credits.creditsCharged, the actual charge. GET /v1/credits returns remaining, the balance in dollars. A small pre-flight that prices a planned batch and compares it with the balance:

import os, requests

API = "https://api.answerline.dev"
HEADERS = {"Authorization": f"Bearer {os.environ['API_KEY']}", "Content-Type": "application/json"}

BASE = {"CHATGPT": 0.0006, "GEMINI": 0.0006, "COPILOT": 0.00274, "PERPLEXITY": 0.0015, "GROK": 0.00218, "AIMODE": 0.00206, "GOOGLE": 0.00103, "GOOGLE_NEWS": 0.0002}
EXTRA_PAGE = {"GOOGLE": 0.00071}

def max_price(task_type, payload):
    inc = payload.get("include", {})
    price = BASE[task_type] + EXTRA_PAGE.get(task_type, 0) * (payload.get("pages", 1) - 1)
    if task_type == "GOOGLE" and "aioverview" in inc:
        price += 0.00071
    return price

def preflight(tasks):
    planned = sum(max_price(t["taskType"], t["payload"]) for t in tasks)
    balance = requests.get(f"{API}/v1/credits", headers=HEADERS, timeout=30).json()
    print(f"planned max ${planned:.5f}, remaining ${balance['remaining']}")
    return planned <= balance["remaining"]

Treat this as an estimate; the server’s creditsToCharge on each created task is authoritative. Within a batch, the balance is checked in order, so if the balance runs short the later items come back with INSUFFICIENT_CREDITS while the earlier ones are created. Log those per item rather than assuming the whole batch failed.

How charging behaves

• A request reserves its maximum cost, then is charged the actual cost on success.
• Failed requests are not charged, and neither are queued tasks you clear with DELETE /v1/async/queue.
• A task that cannot start within 4 hours fails uncharged.
• When the balance runs out, requests get 403 INSUFFICIENT_CREDITS. Nothing is billed beyond what you topped up, so the risk is missing data, not a surprise invoice.

An empty balance therefore stops collection partway through the month. Leave headroom, turn on auto top-up, or schedule the most important cells first and give them a higher priority.

Planning for several clients or brands

Agencies and teams tracking several brands share one account’s balance and queue, so plan the account, not each client in isolation:

1. Price each client with the formula above and keep the per-client totals; they are the basis for your own client pricing and reporting.
2. Sum the clients and add headroom for pilots and ad-hoc checks before topping up.
3. Tag tasks by client in the idempotencyKey (for example client-a:2026-09-17:CHATGPT:US:p014), so every delivered result and its credits.creditsCharged can be attributed.
4. Use priority to decide which client’s work starts first when the queue is long; it orders only your own queue.
5. Watch the balance with GET /v1/credits and stop submitting low-priority work when remaining falls below what the rest of the month needs.

There is no concurrency cap; the queue (about 100,000 tasks of a typical prompt) is per account, so a large client batch can delay the others’ tasks rather than failing them. The agency tracking post covers the reporting side.

Where teams overspend

• Every engine on every prompt. Brand prompts may need all engines; long-tail category prompts may need one or two.
• Markets that do not change decisions. A market multiplies everything.
• Daily cadence on settled answers. If a cell’s mention rate sits near 100% or 0% for weeks, weekly is enough.
• Add-ons left on by default. Extra Google Search pages are charged on every run, the AI Overview on every run that shows one.
• Re-collecting for another view. Store the full result once and derive new metrics from storage.

The pilot

Before committing to a budget, run a reduced version for two weeks: for example 20 prompts, one market, the engines you are unsure about, daily. It costs 20 × 14 × ($0.0006 + $0.0006) = $0.336 for ChatGPT and Gemini. Then check whether the engines disagree enough to justify keeping both, and whether weekly sampling would have led to the same conclusions as daily. Scale only the dimensions that changed a decision.

Start with the quickstart, or read the full price rules on /docs/credits.

Keep reading