Skip to content

Integration

How to run one prompt on multiple AI engines with an API

An engine list, a batch of up to 500 tasks, or your own fan-out: the same prompt on ChatGPT, Gemini and Perplexity costs from $2.60 to $39 per 1,000 prompts.

One line enters a cube and splits into three lines ending in small diamonds

SEO consultant, and more recently GEO, at MentionBox

One HTTP request can bring back one answer per engine, and only two API shapes actually do it. An execution endpoint takes the engine list in the body: API for GEO documents "models": ["chatgpt", "perplexity", "google-ai-mode"] on POST /v1/prompts/run and bills one credit per prompt, per model and per run, so a three-engine prompt is 3 credits, $0.039 at its entry rate of $0.013. A batch endpoint carries one task per engine, up to 500 tasks in cloro's case, each task naming its own engine. Everything else sold as a single call is either one key over many models, which still answers one model per request, or a read against answers a platform collected on its own schedule.

This guide is written for the developer who has to collect the same prompt from several engines and wants to know which part of the fan-out belongs in the API and which part belongs in the code. API for GEO is our editorial pick after hands-on testing by Mathias C., because the engine list and the per-brand figures come back in the same response, and the cheaper scraping routes win when you have someone to write the counting. Below: the five routes with their request shapes, the field names you have to normalise, what 1,000 three-engine prompts cost on each route, and the failures that surface in the first week. Prices and capabilities of the APIs this site rates come from each vendor's pricing page and reference, checked on October 23, 2026; endpoints and official engine rates were read on November 12, 2026.

One word needs fixing before the routes. Sending your prompt to several engines is a fan-out you control. The query fan-out is a different thing, done inside the engine: the searches it writes for itself before answering. Both appear below, and they are billed by different parties.

What "one API call" turns out to mean

Three readings circulate, and they cost different amounts of work:

  • One HTTP request that returns several answers. Routes 1 and 2 below. The request is one, the billing is still per answer.
  • One credential over several providers. A gateway. The code loses three auth schemes and keeps the loop over engines.
  • One unit of billing. Nobody sells this. Every vendor in this market bills prompt × engine × run, under the name credit, task, response or execution.

The second question decides more than the first: who runs the prompt, and against what. An official model API answers from the model you named, with a search tool you attached. A scraping API answers from the interface a buyer sees. Our comparison of the OpenAI web search tool against ChatGPT answers sets out that gap in detail, and it survives every routing trick below.

RouteEngines per HTTP requestWhat comes backPrice per 1,000 answers
API for GEO, engine list on one POSTall the engines you nameanswer, ranked sources, mentions, position, share of voice, sentiment, themes, fan-out questions$13, down to $7 at the largest tier
cloro, batch of async tasksup to 500 tasks, one engine eachanswer, sources, entities on ChatGPT, fan-out queries, shopping cards$4 at the $30 Lite plan rate
DataForSEO, task array per platform100 tasks, one platform per callanswer, cited URLs, brands named, fan-out queries$1.20 on the standard queue
LLM Pulse, platform run, one read callall engines in the projectmentions, visibility, share of voice, position, sentiment, citations€30.67 at the €299 Scale plan rate
Official engine APIs, one call eachone model per requestanswer, citations, the searches the model ranabout $26.50 of tool fees per 1,000 three-engine prompts

Published rates and fields from each vendor's pricing page and API reference, checked on October 23, 2026, and from OpenAI's, Google's and Perplexity's pricing pages for the last line, read on November 12, 2026. For API for GEO, its price per answer is the highest of the four APIs listed, about ten times DataForSEO's; 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 on October 26, 2026, along with its webhooks, OpenAPI spec and official SDKs.

Route 1: an execution endpoint that takes the engine list

This is the shape people have in mind when they search for one call. The engine list is an array in the body, and the response holds one block per engine. API for GEO publishes the request on its home page:

curl -X POST https://api.apiforgeo.com/v1/prompts/run \
  -H "Authorization: Bearer $API_FOR_GEO_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "best project management tool for creative agencies",
    "models": ["chatgpt", "perplexity", "google-ai-mode"],
    "country": "US",
    "language": "en",
    "enrich": ["entities", "citations", "sentiment", "themes", "shopping", "fanouts"]
  }'

Two details in that body carry most of the value. The enrich array decides how much analysis arrives computed: the documented response holds entities with a rank, a mentions count, a share_of_voice percentage and a sentiment score from 0 to 100, plus citations, themes and fan_outs. And the country plus language pair applies to every engine in the list, which is what makes the three answers comparable in the first place.

The same endpoint family has an asynchronous twin for volume. Its Prompt Tracking page documents POST /v1/jobs/execute, which takes the stored prompt ids, the same models array and an executionsPerQuery count, and returns a job to poll rather than an answer. Use the synchronous route to try a prompt and the job route for anything scheduled, because the synchronous example on the vendor's own page carries a 90-second timeout, and the slowest engine in your list sets the wait.

Three facts decide whether this route fits your budget, all from the pricing page checked on October 23, 2026. One credit is one prompt, executed once, against one model, in one locale, enrichments included, at $0.013 falling to $0.007 per credit on volume, with no monthly minimum published and no expiry on credits. Reads over runs already collected are not billed, so re-reading a month of answers after you change a definition costs nothing. The pay-as-you-go tier is capped at 300 requests per minute and 10 concurrent executions, which is the number to divide your prompt list by when you size a nightly job.

The limits are worth stating plainly. Its price per answer is the highest of the four APIs in this guide, about ten times DataForSEO's. Of the ten engines this site tracks, 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 on October 26, 2026, along with the webhooks, the OpenAPI spec and the official SDKs, none of which are documented on the vendor's site yet. The key arrives on request rather than by instant sign-up. Our score for it is 9.0 out of 10, the best of the 55 APIs this site rates. MentionBox, which publishes this site, has a commercial link with API for GEO.

Route 2: one batch request carrying one task per engine

Scraping APIs expose one endpoint per engine, which looks like the opposite of a single call until you reach the batch endpoint. cloro's single-engine routes are /v1/monitor/chatgpt, /v1/monitor/gemini and /v1/monitor/perplexity, one request each. Its OpenAPI document also carries POST /v1/async/task/batch, which takes an array of 1 to 500 items, and each item names its own engine:

curl -X POST https://api.cloro.dev/v1/async/task/batch \
  -H "Authorization: Bearer $CLORO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {"taskType": "CHATGPT", "payload": {"prompt": "best project management tool for creative agencies", "country": "US"},
     "idempotencyKey": "2026-11-12-p001-chatgpt", "webhook": {"url": "https://example.com/hooks/cloro"}},
    {"taskType": "GEMINI", "payload": {"prompt": "best project management tool for creative agencies", "country": "US"},
     "idempotencyKey": "2026-11-12-p001-gemini", "webhook": {"url": "https://example.com/hooks/cloro"}},
    {"taskType": "PERPLEXITY", "payload": {"prompt": "best project management tool for creative agencies", "country": "US"},
     "idempotencyKey": "2026-11-12-p001-perplexity", "webhook": {"url": "https://example.com/hooks/cloro"}}
  ]'

The per-item taskType, payload, priority, idempotencyKey and webhook fields come from that document, read on November 12, 2026, and cloro's changelog dates the endpoint to April 9, 2026 with "up to 500 tasks per request". The idempotency key is the field that pays for itself: a retried batch after a network error charges nothing twice.

Credits differ by engine, which is where a three-engine fan-out stops being three identical units. At the rates checked on October 23, 2026, ChatGPT costs 5 credits, Gemini 4 and Perplexity 4, so one fan-out is 13 credits; the synchronous endpoints add 2 credits each, and the ChatGPT add-ons for shopping, fan-out queries and the raw response add 2 more. On the $30 Lite plan, 37,500 credits work out at $0.80 per 1,000 credits, which puts the fan-out at $0.0104 and 1,000 of them at $10.40, within the plan. Deliveries arrive by webhook with an optional HMAC-SHA256 signature, five attempts, and results kept for 24 hours, so the receiver has to be live before the batch goes out. cloro gives 500 free credits a month on its Free plan, which is one concurrent job and enough to test the shape. Two limits: Claude is absent, with the documentation stating that access conflicts with Anthropic's terms of service, and the terms forbid reselling the service.

DataForSEO batches the same way with a narrower reach per call. Its ChatGPT LLM Responses task_post accepts up to 100 tasks per POST under a ceiling of 10,000 API calls per minute, with user_prompt capped at 500 characters, a model_name per task, and postback_url or pingback_url for delivery, both accepting $id and $tag substitution. The platform sits in the path rather than in the body, so three engines are two or three calls: the LLM Scraper covers the interfaces of ChatGPT and Gemini at $0.0012 per result on the standard queue, $0.0024 on the priority queue and $0.004 live, with the page stating that "to date, only ChatGPT and Gemini are supported", while Perplexity and Claude arrive through LLM Responses at $0.0002 per task plus the price the model provider charges, under an automatic $0.01 advance payment per task that is reconciled afterwards. Standard tasks may take up to 72 hours to complete, which rules the queue out of anything interactive.

Four rules keep a batch honest:

  • One idempotency key per prompt, engine, country and date. Retries then cost nothing, and a duplicate row never reaches the report.
  • One webhook endpoint, one dispatcher. Route on the task type inside the payload rather than running a handler per engine.
  • Store the engine's own error. A batch of 300 tasks rarely comes back whole, and a missing answer is not the same figure as an answer without your brand.
  • Keep the raw payload. Both vendors return fields your first schema will not have room for, and recounting beats recollecting.

Route 3: one key over many models, still one answer per request

A gateway solves authentication rather than fan-out. Perplexity's Agent API reaches models from OpenAI, Anthropic, Google, xAI and Perplexity on one key, with a single model per request in provider/model-name form, web search attached as an opt-in tool, and a background flag for long jobs:

curl https://api.perplexity.ai/v1/agent \
  -H "Authorization: Bearer $PERPLEXITY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.6-sol",
    "input": "best project management tool for creative agencies",
    "tools": [{"type": "web_search"}]
  }'

Perplexity's own cookbook on multi-provider orchestration is explicit about the loop: to "send the same prompt to multiple models and compare quality, latency, and cost", it iterates over model ids and calls the endpoint once per model, recording latency and cost each time. The models array on the same API is a fallback chain, documented as accepting up to five entries, and it tries the next model when one fails instead of answering from all of them. Third-party usage is billed at each model's published rates, consolidated on one invoice, and the web_search tool is $0.0025 per invocation, or $0.001 with Fast Search.

Google ships the same idea at the infrastructure layer. Its model routing in API Gateway, announced in public preview on August 4, 2026, accepts OpenAI-compatible requests at one stable endpoint and routes each one to Gemini, Claude or an OpenAI open-weight model by configuration. One request, one backend.

For an application that needs an answer, this route is the clean one. For measurement it answers a different question from the one a brand team asks: a gateway answer comes from a model you selected with instructions you wrote, and the same gateway gives you no access to Google AI Mode, Google AI Overviews or the ChatGPT interface, since none of them is a model endpoint. Our page on getting Google AI Mode answers through an API covers that gap.

Route 4: the platform runs the prompts, your call reads them

A third family inverts the problem. You register prompts, the platform runs them on every engine in your project on its own cadence, and your single call is a read that already spans the engines. LLM Pulse documents a base URL of https://api.llmpulse.ai/api/v1 with a prompts endpoint that bulk-creates up to 100 prompts, dimensions and metrics endpoints that return share of voice and timeseries, an answers endpoint for the full model responses, and a 300 requests per minute limit. Its coverage is the widest we recorded, all ten engines this site tracks, at €30.67 per 1,000 answers on the €299 Scale plan with weekly tracking, checked on October 23, 2026. SE Ranking's Data API goes further in the same direction: the answers come from its own AI Search database rather than from a prompt list of yours, refreshed monthly, at €36 per 1,000 prompt answers on its wallet rate.

The trade is control over timing. A read-only API cannot run your prompt now, so an on-demand feature in your product has nothing to call, and the cadence you can report on is the one the plan sells. For a weekly or monthly dashboard the arrangement removes the whole collection layer, which is work you no longer maintain.

Route 5: your own fan-out on the official engine APIs

Three calls, in parallel, with your own concurrency. The request shapes differ enough that each needs its own adapter:

EngineRequestSearch toolWhat identifies a searched answer
ChatGPT modelsPOST https://api.openai.com/v1/responses, model, inputtools: [{"type": "web_search"}], forced with tool_choice: "required"a web_search_call output item with the queries it ran
GeminiPOST https://generativelanguage.googleapis.com/v1beta/interactions, model, inputtools: [{"type": "google_search"}]a google_search_call step holding queries
PerplexityPOST https://api.perplexity.ai/v1/agent, model, inputtools: [{"type": "web_search"}]an output item of type search_results with queries and results

Request shapes from each provider's own tool documentation, read on November 12, 2026.

The tool fees are published and they add up per engine rather than per prompt. OpenAI prices web search at "$10.00 / 1k calls" with "search content tokens billed at model rates", and its guide for the tool notes that "the model can choose to search the web or not based on the content of the input prompt", with tool_choice: "required" as the lever and filters accepting up to 100 allowed or blocked domains. Google prices Grounding with Google Search at $14 per 1,000 requests on Gemini 3 and newer models, after 5,000 free search requests a month and under a daily cap of 1,500. Perplexity's web_search is $2.50 per 1,000 invocations, or $1.00 with Fast Search. One prompt on the three, with one search each, is about $0.0265 of tool fees plus tokens, so 1,000 of them is about $26.50 before the model bills arrive.

Two further facts shape the design. The engines answer at different speeds, so asyncio.gather with a per-engine timeout and a recorded failure beats a sequential loop that one slow engine stalls; the Gemini daily cap of 1,500 search requests per project is the ceiling a nightly job hits first, and a prompt that fans out into five internal searches consumes five of them. And the answer you collect is the model's, not the assistant's: Perplexity's own FAQ states that the API and the web interface "share search infrastructure, but their tools, configuration, and models differ, so results can differ".

Normalising three answers into one row

The reporting code should never know which route the answer came from. One adapter per route, four normalised fields, and the raw payload kept whole:

Normalised fieldOpenAI ResponsesGemini InteractionsPerplexity Agent APIcloroAPI for GEO
answer textmessage item textanswer textoutput message itemtext, markdownanswer_text
sourcesurl_citation annotationsurl_citation annotationssearch_results.results[]sources[] with url, label, datesources[] with url, domain, category
searches the engine ranweb_search_call.action.queriesgoogle_search_call.queriessearch_results.queriessearchQueries on ChatGPT and Perplexityfan_outs
brands namednot returnednot returnednot returnedentities on ChatGPTentities[] with rank, mentions, share of voice, sentiment

Field names from each vendor's API reference and tool documentation, checked on October 23, 2026 for the two APIs and read on November 12, 2026 for the engine APIs.

The last row is the whole economic question of this article. On the official APIs and on a scraper, the brand layer is code you write: match each brand through a list of variants including the legal name, the product names and the domain, count one answer once however many times a name appears, read the rank of the first mention, then divide. On a GEO API the same figures arrive computed, and the price per answer carries that work. Our explainer on share of voice, visibility and position gives the four formulas if you are writing them yourself.

Four columns belong in the stored row whatever the route: the engine id, the collection method, the country and language, and whether a search ran. A month that mixes searched and unsearched answers measures two populations, and nothing in the figures says so afterwards.

What 1,000 three-engine prompts cost

One prompt on ChatGPT, Gemini and Perplexity is three answers. One thousand prompts, one run each, is 3,000 answers:

RoutePer three-engine promptPer 1,000 promptsEntry ticket
API for GEO, one POST with three models3 credits, $0.039$39, metrics computedpay as you go, no minimum published
cloro, one batch of three async tasks13 credits, $0.0104$10.40 of credits$30 Lite plan, 37,500 credits a month
DataForSEO, two calls, standard queueabout $0.0026 of task feesabout $2.60 plus the Perplexity token bill$50 minimum payment
Official engine APIs, three callsabout $0.0265 of tool feesabout $26.50 plus model tokenspay as you go per provider

Our arithmetic on published rates: API for GEO and cloro and DataForSEO checked on October 23, 2026, OpenAI, Google and Perplexity read on November 12, 2026. Gemini's 5,000 free search requests a month are not deducted in the last line.

The ranking flips once you count the engineering. The two cheap routes return answer text, links and named entities, and leave the per-brand figures to your code; the $39 line returns share of voice, position, sentiment, ranked sources, themes and the fan-out questions in the same response. Our ranking of self-serve APIs for developers sorts the field on the criteria that matter for this job, a self-serve key, a readable price and the tooling around the API. The full basket arithmetic for a bigger programme sits in our guide on the cost of tracking 100 prompts on five AI engines.

Errors that surface in the first week

  • A synchronous fan-out that waits on the slowest engine. The vendor example for a synchronous run carries a 90-second timeout, and your three-engine call inherits the worst of the three. Anything scheduled belongs on the job or batch route with a webhook.
  • Retries that bill twice. Without an idempotency key, a timeout you did not read still ran the prompt. cloro accepts one per task; on routes without the field, store your own request id and check before resending.
  • A partial batch counted as a complete run. Record the per-task error and exclude failed tasks from the denominator, otherwise a Gemini outage reads as a visibility drop.
  • Concurrency caps found in production. API for GEO's pay-as-you-go tier publishes 10 concurrent executions and 300 requests per minute, cloro's Lite plan 10 concurrent jobs, DataForSEO 10,000 API calls per minute. Divide the prompt list by the cap before you schedule, not after.
  • Comparing an engine against itself across routes. A ChatGPT answer scraped from the interface and one taken from the Responses API are two measurements. Keep the collection method in the key, or the trend line records your change of vendor.
  • One run per prompt. A single answer is one draw, and the engines do not repeat themselves. Several runs per prompt per period is the floor for any figure you report, which is also the cheapest thing to get wrong, since it multiplies the whole bill.

Our view

Pick the route on who writes the brand layer, not on the number of HTTP calls:

  1. A product feature that answers on demand. The engine-list endpoint, because one request returns the whole comparison and the figures arrive computed. API for GEO at $13 per 1,000 answers down to $7, our score 9.0 out of 10, with the caveats stated above on price per answer and on the four engines and the tooling that our test confirmed rather than its documentation.
  2. Volume collection with developers on hand. The batch route. cloro for breadth of country coverage and a documented browser method at $4 per 1,000, our score 7.4; DataForSEO for the lowest price per answer at $1.20 per 1,000 with SDKs in four languages and an MCP server, our score 7.7. Both leave share of voice, position and sentiment to your code.
  3. A weekly or monthly dashboard with no collection layer to maintain. The platform-run route, LLM Pulse at €30.67 per 1,000 answers across ten engines, our score 8.8, with the cadence set by the plan rather than by your scheduler.
  4. An application that needs a good answer rather than a measurement. A gateway, with one key and one model per request, and no illusion that it measures what a buyer reads.

Frequently asked questions

Can one API call run the same prompt on ChatGPT, Gemini and Perplexity?

Yes, through two API shapes. An execution endpoint takes the engine list in the body: API for GEO publishes `"models": ["chatgpt", "perplexity", "google-ai-mode"]` on `POST /v1/prompts/run` and returns one answer plus the computed per-brand figures for each engine named. A batch endpoint carries one task per engine instead: cloro's `POST /v1/async/task/batch` accepts 1 to 500 tasks, each with its own `taskType` and payload, so a single request can mix ChatGPT, Gemini and Perplexity. Either way you are billed per answer, not per request.

Does the Perplexity Agent API let me query several models in one request?

Not in parallel. Its overview documents a single `model` per request in `provider/model-name` form, with models from OpenAI, Anthropic, Google, xAI and Perplexity reachable on one key, and its own cookbook on multi-provider orchestration loops over the model ids to compare the same prompt. The `models` array is a fallback chain of up to five entries, which tries the next model when one fails rather than answering from all five. Third-party usage is billed at each model's published rates on one invoice.

How much does the same prompt on three AI engines cost?

For 1,000 prompts run on ChatGPT, Gemini and Perplexity, which is 3,000 answers: $39 with API for GEO at $0.013 per credit, with share of voice, position, sentiment, ranked sources and fan-out questions returned; about $10.40 of credits on cloro's $30 Lite plan, at 5 credits for ChatGPT and 4 each for Gemini and Perplexity; about $2.60 of task fees on DataForSEO plus whatever Perplexity charges for the tokens, after its $50 minimum payment. Prices checked on October 23, 2026.

Is it cheaper to call the official engine APIs myself?

On tool fees the three official routes come to about $26.50 per 1,000 three-engine prompts, plus tokens: OpenAI bills web search at $10.00 per 1,000 calls, Google bills Grounding with Google Search at $14 per 1,000 requests after 5,000 free a month, and Perplexity bills its `web_search` tool at $2.50 per 1,000 invocations, or $1.00 with Fast Search. You also write the counting, and you measure the model you configured rather than the assistant your buyers use. Rates read on November 12, 2026.

Which engines cannot be reached through an official API?

Google AI Mode and Google AI Overviews are features of Google Search, and Google publishes no API that returns their answers, so both arrive through a scraping API or not at all. Claude is absent from cloro, whose documentation states that access conflicts with Anthropic's terms of service, and DataForSEO's LLM Scraper page states that "to date, only ChatGPT and Gemini are supported" for interface capture, with Claude and Perplexity reached through the official model APIs instead. Checked on October 23, 2026 for the vendors, November 12, 2026 for the engine documentation.

How do I store answers from three engines in one table?

Normalise four fields and keep the rest as raw JSON: the answer text, the source list, the searches the engine ran, and the engine id with its collection method. The names differ by route, `url_citation` annotations on OpenAI and Gemini, a `search_results` item on Perplexity's Agent API, `sources` on cloro, `citations` on API for GEO, so the mapping belongs in one adapter per route rather than in the reporting code. Store the raw payload next to the normalised row, because a change in your matching rules then costs a recount instead of a new collection.