Skip to content

Integration

How to get AI Overviews data into Google Sheets with an API

An Apps Script trigger with UrlFetchApp writes one row per AI Overview every 10 minutes. The data bill for 800 keyword checks: $2.20 to $10.40 a month.

A blue sphere flows through a tube into one cell of an isometric grid

SEO consultant, and more recently GEO, at MentionBox

To get Google AI Overviews into a spreadsheet and keep a history, write an ordinary Apps Script function that calls an AI Overviews API with UrlFetchApp.fetchAll, appends the rows with Range.setValues, and run it on an installable time-driven trigger every 10 minutes in batches of 10 keywords. A cell formula cannot do the job: Google caps a custom function at 30 seconds per execution, while one asynchronous overview request takes 30 to 60 seconds by cloro's own published latency. For 200 keywords checked weekly, the data costs $2.20 a month with DataForSEO's live Google SERP endpoint and $10.40 with API for GEO, our editorial pick after hands-on testing by Mathias C., which is the only one of the four that fills a share of voice column without arithmetic in the sheet.

This guide is written for a brand team that already reports in Google Sheets and wants AI Overview presence, sources and brand mentions in the same file as the rest of its search data. It covers the four routes into a spreadsheet, the API choice and its price, the collector script, the scheduling limits that decide the batch size, the Sheets API alternative for teams that collect outside the spreadsheet, and the errors that show up in the second month. Prices, endpoints and quotas come from each vendor's documentation and from Google's own references, checked on October 23, 2026. MentionBox, which publishes this site, has a commercial link with API for GEO.

The four routes into a spreadsheet

RouteWhat runs the requestKeeps a dated historyNeeds an API key in the sheetHard limit that decides it
Vendor add-on function, such as SERPAPI_RESULT()the add-onno, the cell recalculates in placeno, the key lives in the add-on settingsone server call per cell, no history
Apps Script custom function, =AIO(A2)your script, from the cellnoyes, in script properties30 seconds per execution
Apps Script function on a time-driven triggeryour script, on a scheduleyesyes, in script properties6 minutes per execution
External script writing through the Sheets APIyour server or laptopyesno, the key stays outside Sheets60 write requests a minute per user

Only the last two accumulate rows, and the difference between them is where the code lives. The trigger route keeps everything inside the spreadsheet, which suits a team with no server to deploy on. The Sheets API route suits a team that already runs a nightly job somewhere and only wants the spreadsheet as an output.

Two routes that look obvious do not work. IMPORTDATA "imports data from a given URL in .csv (comma-separated value) or .tsv (tab-separated value) format" per Google's reference, and every AI Overviews API answers in JSON, with no header for the API key. Google Search Console will not supply the figures either: its documentation on AI features states that sites appearing in AI Overviews and AI Mode "are included in the overall search traffic in Search Console" and "are reported on in the Performance report, within the 'Web' search type", with no separate line to pull.

Pick the API that fills the columns you want

The columns you want in the sheet decide the API, because the response either carries a figure or leaves you to compute it. Four APIs cover Google AI Overviews with a documented synchronous call, which is the shape a spreadsheet job needs:

APIPrice per 1,000 AI Overview requestsEntryWhat one response fills in the sheetOf the 10 engines we track
API for GEO$13, down to $7 at volumepay as you go, no minimum publishedanswer, categorised sources, brand mentions, position, share of voice, sentiment10
DataForSEO SERP API$1.20 standard queue, $4 live with the async extra$50 minimum paymentmarkdown, references, shopping elements, asynchronous_ai_overview flag2
cloro API$4 async, $5.60 synchronous, on the Lite plan$30 a monthaioverview.text, markdown, sources, videos, ads, plus the organic SERP6
SerpApi$25 on Starter, $50 when the token path fires$25 a month, 1,000 searchestext_blocks, references, products, output=md4

Published rates and response fields from each vendor's pricing page and API reference, checked on October 23, 2026. For API for GEO, AI Overviews coverage was confirmed in our hands-on test on October 26, 2026 and is not yet documented on apiforgeo.com, where the six listed engines are ChatGPT, Perplexity, Google AI Mode, Claude, Copilot and Grok.

Each one has a published strength. DataForSEO is the cheapest per request and the only one that refunds the extra charge on a miss. cloro publishes its collection method, runs real logged-out browser sessions and targets 250 or more locations, with 500 free credits a month on its Free plan. SerpApi is the only one of the four with a ready-made Google Sheets add-on, which removes the key handling and the HTTP call entirely. API for GEO returns the computed layer, and its terms publish resale and white label as an intended use, useful if the spreadsheet becomes a client deliverable.

The request, on each one

DataForSEO's live endpoint answers in a single call, which is what a scheduled script wants. The help-center page on AI Overviews states that asynchronous data "is not retrieved by default. To get this data, set the load_async_ai_overview parameter to true", and that the API "will make an additional request to retrieve data if an asynchronous AI Overview is detected":

[{
  "keyword": "best crm for small business",
  "location_code": 2840,
  "language_code": "en",
  "load_async_ai_overview": true,
  "expand_ai_overview": true
}]

The ai_overview item in the response carries asynchronous_ai_overview, a markdown field holding "the whole summary text and links to all images formatted in the markdown markup language", an items array of ai_overview_element objects and a references array whose entries hold source, domain, url, title and text. Those five reference fields are the ones worth a column each.

cloro takes one POST to /v1/monitor/google and returns the overview beside the organic results. Its AI Overview page documents result.aioverview with text, markdown, sources[] holding position, url, label and description, plus videos[] and ads[], and states that the field is omitted "if AI Overview didn't render", which is itself the presence flag for your sheet.

SerpApi needs two calls in the worst case, and both have to happen inside the same execution. The overview arrives inline on engine=google, with ai_overview.text_blocks and ai_overview.references, each reference holding title, link, snippet, source and index. When Google loads it late, the response carries ai_overview.page_token instead, and the Google AI Overview API reference warns that the token "expires within 1 minute of the search and should be used immediately". Its coverage is also narrower than the others: "currently, the AI Overview block is only seen for English searches (hl=en) with a limited range of countries (gl)", per the AI Overview results page.

API for GEO takes the prompt rather than the keyword, and returns the figures with the answer:

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 crm for small business",
    "models": ["google-ai-mode"],
    "country": "US"
  }'

The response holds answer_text, a sources[] array with url, domain, category and mentionsBrand per source, and per-entity shareOfVoice, avgPosition and a sentiment score, which is one spreadsheet column each with nothing to compute. One credit is one prompt executed once against one model in one locale, enrichments included, at $0.013 on the first tier and $0.007 above a million credits a month, with no monthly minimum and credits that do not expire. The synchronous example on apiforgeo.com carries a 90-second timeout, which rules out the formula route and sets the batch size on the trigger route.

Lay out the sheet before you write any code

Two tabs and a fixed column order save a rewrite in month two. A keywords tab holds the input, one row per keyword with its country and language. An overviews tab holds the output, one row per check:

  • Date of the run, written by the script, not by NOW().
  • Keyword, country, language, copied from the input row so the output row stands alone.
  • Overview present, yes or no, from whether the item or field exists in the response.
  • Loaded asynchronously, from asynchronous_ai_overview on DataForSEO or from the presence of page_token on SerpApi. Cached and generated overviews are not the same measurement, and on DataForSEO they are not the same price.
  • Reference count, the length of the references array.
  • Your domain cited, yes or no, and your position in the reference list, from the index of the first match.
  • Brands named, the matched names from your own brand list.
  • Cited domains, joined into one cell for a quick scan, with the full list kept in a third tab if you want one row per source.

Keep the long overview text out of the main tab. Google's file size page allows "up to 20 million cells or 100 MB for spreadsheets that are created in or converted to Google Sheets", and the megabyte limit is the one a stored markdown field pushes against first.

The collector script

The pattern below follows Google's own best practices page, which recommends reading and writing in one command because "alternating read and write commands is slow", and recommends an installable time-driven trigger plus the Properties service to store state such as the last processed row and resume on the next run. The key goes into script properties, never into a cell: Google's properties guide describes the script store as holding "app-wide configuration data, like the username and password for the developer's external database", with a 9 KB ceiling per value.

const BATCH = 10;

function collectOverviews() {
  const book = SpreadsheetApp.getActive();
  const input = book.getSheetByName('keywords');
  const output = book.getSheetByName('overviews');
  const store = PropertiesService.getScriptProperties();

  const auth = 'Basic ' + Utilities.base64Encode(
    store.getProperty('DFS_LOGIN') + ':' + store.getProperty('DFS_PASSWORD'));

  const total = input.getLastRow() - 1;
  const cursor = Number(store.getProperty('CURSOR') || 0);
  const size = Math.min(BATCH, total - cursor);
  const batch = input.getRange(2 + cursor, 1, size, 3).getValues();

  const requests = batch.map(function (row) {
    return {
      url: 'https://api.dataforseo.com/v3/serp/google/organic/live/advanced',
      method: 'post',
      contentType: 'application/json',
      headers: { Authorization: auth },
      muteHttpExceptions: true,
      payload: JSON.stringify([{
        keyword: row[0],
        location_code: Number(row[1]),
        language_code: row[2],
        load_async_ai_overview: true,
        expand_ai_overview: true
      }])
    };
  });

  const stamp = new Date();
  const rows = UrlFetchApp.fetchAll(requests).map(function (response, i) {
    if (response.getResponseCode() !== 200) {
      return [stamp, batch[i][0], 'error ' + response.getResponseCode(), '', '', ''];
    }
    const body = JSON.parse(response.getContentText());
    const items = (body.tasks[0].result && body.tasks[0].result[0].items) || [];
    const aio = items.filter(function (it) { return it.type === 'ai_overview'; })[0];
    const refs = aio && aio.references ? aio.references : [];
    const domains = refs.map(function (r) { return r.domain; });
    return [
      stamp,
      batch[i][0],
      aio ? 'yes' : 'no',
      aio ? aio.asynchronous_ai_overview : '',
      refs.length,
      domains.join(', ')
    ];
  });

  output.getRange(output.getLastRow() + 1, 1, rows.length, 6).setValues(rows);
  store.setProperty('CURSOR', String((cursor + size) % total));
}

Four details in that script are dictated by the limits. UrlFetchApp.fetchAll sends the batch in parallel, which keeps the execution inside the 6-minute ceiling where a sequential loop would not. muteHttpExceptions: true makes a failed request return an HTTPResponse instead of throwing, per the UrlFetchApp reference, so one bad keyword does not lose the other nine rows. The single setValues call writes the whole batch at once, which the best practices page measures as the difference between about 70 seconds and 1 second on 10,000 cells. And the cursor in script properties lets the next run pick up where this one stopped.

For SerpApi the two calls belong in one function, because of the one-minute token life:

function serpapiOverview(keyword, key) {
  const base = 'https://serpapi.com/search?api_key=' + key;
  const first = UrlFetchApp.fetch(base + '&engine=google&gl=us&hl=en&no_cache=true&q=' +
    encodeURIComponent(keyword), { muteHttpExceptions: true });
  const aio = JSON.parse(first.getContentText()).ai_overview;
  if (!aio) return null;
  if (!aio.page_token) return aio;
  const second = UrlFetchApp.fetch(base + '&engine=google_ai_overview&page_token=' +
    encodeURIComponent(aio.page_token), { muteHttpExceptions: true });
  return JSON.parse(second.getContentText()).ai_overview;
}

Note that the second call is a second search credit. On the $25 Starter plan that turns a $0.025 check into a $0.05 one, and the pricing page sells a fixed monthly count rather than a balance, so a month with more deferred overviews than you budgeted ends in a plan upgrade rather than a slightly larger invoice.

Schedule it without hitting the six-minute wall

The batch size is not a style choice. Google's quotas page sets the limits that bound the job:

LimitConsumer accountGoogle Workspace account
Script runtime6 min / execution6 min / execution
Custom function runtime30 sec / execution30 sec / execution
URL Fetch calls20,000 / day100,000 / day
Triggers total runtime90 min / day6 hr / day
URL Fetch response size50 MB / call50 MB / call
Simultaneous executions per user30 / user30 / user

Figures from Google's Apps Script quotas reference, read on November 10, 2026. Google notes that quotas are per user, reset 24 hours after the first request, and "are subject to elimination, reduction, or change at any time, without notice."

Put the vendor latency against the 6-minute ceiling and the arithmetic settles the design. cloro publishes a "typical latency of 30 to 60 seconds end-to-end and no caching layer" on its AI Overview endpoint, and API for GEO's synchronous example allows 90 seconds. At 45 seconds a request, eight sequential calls fill a 6-minute execution. With fetchAll the batch finishes in roughly the time of its slowest member, so a batch of 10 completes in about a minute, and 10 also sits inside the published concurrency limits on both ends: cloro allows 10 concurrent jobs on its Lite plan, API for GEO publishes 300 requests a minute and 10 concurrent executions on pay as you go.

Install the trigger from code once, then leave it alone:

function installTrigger() {
  ScriptApp.newTrigger('collectOverviews').timeBased().everyMinutes(10).create();
}

Google's ClockTriggerBuilder reference restricts the interval: with everyMinutes(n), "n must be 1, 5, 10, 15 or 30". Twenty batches of 10 keywords therefore clear 200 keywords in about 200 minutes, using roughly 30 minutes of trigger runtime, inside the 90 minutes a day a consumer account gets. If you would rather run once a day at a set hour, the installable triggers guide warns that the time "might be slightly randomized": ask for 9 AM and "Apps Script chooses a time between 9 AM and 10 AM", then keeps that timing from day to day.

Why a cell formula is the wrong place for the call

A custom function is tempting, because =AIO(A2) reads like the rest of the spreadsheet. Google's custom functions guide rules it out on four counts:

  1. Time. "A custom function call must return within 30 seconds", after which "the cell displays #ERROR!" with the note "Exceeded maximum execution time (line 0)". One asynchronous overview request regularly exceeds that.
  2. Writing. "A custom function can't affect cells other than those it returns a value to", so it cannot append a dated history. For that, Google's own guidance is to "use a custom menu to run a function instead".
  3. Recalculation. Arguments "must be deterministic", NOW() and RAND() are refused as arguments, and the function "doesn't recalculate until you edit the function, or you change the value of a referenced cell". A collector that only refreshes when someone edits the sheet is not a collector.
  4. Volume. "Each time a custom function is used in a spreadsheet, Sheets makes a separate call to the Apps Script server", and with hundreds of calls "this process can be slow".

URL Fetch is on the list of services a custom function may use, so the formula does work for a one-off look at a single keyword. For 200 keywords on a schedule, every one of those four points fires at once.

The vendor add-on route sits between the two. SerpApi's add-on, published on the Workspace Marketplace as SerpApi, Search Engine Results and Ranks, holds the key in its own settings and exposes sheet functions including SERPAPI_RESULT() and SERPAPI_RANK. Its own Apps Script walkthrough shows the pairing it recommends, a small custom function wrapped around the add-on function, because "native Google Sheets formulas can't easily parse deeply nested JSON arrays":

function EXTRACT_SNIPPETS(jsonString) {
  const blocks = JSON.parse(jsonString);
  const snippets = blocks.flatMap(block => {
    if (block.snippet) return [block.snippet];
    if (block.list) return block.list.map(item => item.snippet);
    return [];
  });
  return snippets.join('\n');
}

Called as =EXTRACT_SNIPPETS(SERPAPI_RESULT("engine=google&q=drop shipping&google_domain=google.com", "ai_overview.text_blocks")), that returns today's overview text in a cell with no key in the sheet and no HTTP code to write. It still recalculates in place, so pair it with the trigger route rather than treating it as the archive.

Writing from outside the spreadsheet with the Sheets API

If the collection already runs in Python or Node somewhere, skip Apps Script and append rows over HTTP. The Sheets API reference documents one call for it:

curl -X POST \
  "https://sheets.googleapis.com/v4/spreadsheets/$SHEET_ID/values/overviews!A1:append?valueInputOption=RAW&insertDataOption=INSERT_ROWS" \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"values": [
    ["2026-11-10", "best crm for small business", "yes", false, 8, "hubspot.com, zoho.com"]
  ]}'

Three points from that reference decide whether the rows land where you expect. The range "is used to search for existing data and find a 'table' within that range", and values "will be appended to the next row of the table, starting with the first column of the table", so point it at A1 of the output tab and let Sheets find the end. insertDataOption=INSERT_ROWS inserts rows for the new data instead of overwriting what sits below the table. And valueInputOption "only controls how the input data will be added to the sheet", with RAW storing strings as typed and USER_ENTERED parsing them the way a person typing would, which is what turns 2026-11-10 into a date.

The quotas are tighter than Apps Script's. The limits page sets 300 read and 300 write requests a minute per project, and 60 of each a minute per user per project, refilled every minute, with a recommended 2 MB maximum payload and a 429: Too many requests response past the limit. Google's advice there is truncated exponential backoff, min(((2^n)+random_number_milliseconds), maximum_backoff) with a maximum typically of 32 or 64 seconds. For a nightly job, one append call carrying 200 rows stays comfortably under 60; one call per keyword does not.

What a month costs

Take a brand team tracking 200 keywords once a week, which is 800 requests a month. Google's documentation is clear that not every check returns an overview, since AI Overviews "are only shown when our systems determine that it is additive to classic Search, and as such, often don't trigger". Under one stated assumption, 600 of the 800 checks return an overview and 300 of those load asynchronously:

API, synchronous pathRequests billedMonthPer 1,000 collected overviews
API for GEO800 credits at $0.013, metrics included$10.40$17.33
DataForSEO SERP API, live advanced800 at $0.002, plus $0.002 on 300 async retrievals$2.20$3.67
cloro API, Lite plan5,600 credits of the 37,500 included$30.00 plan, about $4.48 of credits$7.47 of credits
SerpApi, Developer plan1,100 of the 5,000 searches included$75.00 plan, about $16.50 of quota$27.50 of quota

Our arithmetic on the rates each vendor published, checked on October 23, 2026, under one stated assumption: 600 of the 800 checks return an overview and half of those load asynchronously. Change the assumption and the last column moves on every row.

Four things move those totals before you commit:

  1. The queue, on DataForSEO. The standard queue costs $0.0006 a SERP plus a refundable $0.0006, which would bring the same month to $0.66 rather than $2.20. It needs two phases, task_post then a result fetch, which the trigger pattern can do by storing task IDs in a tab and reading them on the next run. The live endpoint buys simplicity for about $1.54 a month here.
  2. The refund rule. DataForSEO states that "if the asynchronous AI Overview is not available in the SERP, the extra charge will be refunded", and that a cached overview with the parameter on also has "the additional charge refunded". A low trigger rate therefore costs you little on that API and the full plan price on the subscription ones.
  3. The subscription floor. cloro bills $30 a month for 37,500 credits on Lite at $0.80 per 1,000 credits, with an AI Overview including the SERP costing 5 credits on an async request and 7 synchronously; unused credits "expire at the end of the billing period". SerpApi sells 1,000 searches for $25, 5,000 for $75 and 15,000 for $150, so the second token call is what pushes 800 keyword checks over the Starter plan.
  4. The free tiers cover the build. cloro's Free plan gives 500 credits a month with 1 concurrent job, DataForSEO gives $1 of trial credit against a $50 minimum payment, SerpApi gives 250 searches a month, and API for GEO replies to a key request with a sandbox project.

A second cost sits outside the invoice. Every column your sheet has to compute is a formula somebody maintains: matching brand aliases, finding the position of the first mention, counting cited domains and dividing. Our guide on tracking a brand in ChatGPT with an API gives those four formulas with a worked example, and our explainer on GEO metrics defines each one. An API that returns shareOfVoice and avgPosition removes that layer and costs about five times DataForSEO's live rate per request. Which trade is right depends on whether a person or a product reads the sheet.

Errors that surface in the second month

  1. Overwriting instead of appending. A sheet with one row per keyword measures today. Append a dated row, keep the keyword list in its own tab, and the second month has something to compare against.
  2. Treating a missing overview as a failed request. No overview is a measurement: record no in the presence column rather than skipping the row, or your trigger rate is undefined and your cost per collected overview is unknowable.
  3. Mixing cached and asynchronous overviews in one column. They are generated differently, and on DataForSEO they are priced differently. Keep asynchronous_ai_overview as its own column.
  4. Letting NOW() into the sheet. It makes the dated column drift on every recalculation and is refused outright as an argument to a custom function. Stamp the date in the script.
  5. Reporting AI Overviews and AI Mode as one figure. They are separate surfaces with separate endpoints and prices, and Google states that the two "may use different models and techniques, so the set of responses and links they show will vary". Our guide on getting Google AI Mode answers through an API covers the second column.
  6. One check a month per keyword. An overview is regenerated per query, per location and per language. A weekly check costs four times as much and carries a trend instead of a snapshot.
  7. Keeping only the parsed columns. Store the raw JSON, in a tab or in Drive. A change in how you count a mention then costs a recount rather than a fresh month of collection, and the stored references answer the question a brand team actually asks, which is why a competitor was cited.

The sources column is the one that earns the file. Our guide on tracking the AI citations of your pages covers what to do with it, and query fan-out explains why the pages Google cites in an overview often answer a sub-question rather than the keyword you typed.

Our view

Three shapes work, and the right one follows from who reads the spreadsheet:

  1. Cheapest rows, in-house analysis. DataForSEO's SERP API through an Apps Script trigger, at $2.20 a month for 800 live requests or $0.66 on the standard queue, with the refund on misses and the counting formulas on you. Our score: 6.3 out of 10 for the SERP product. Our comparison of SerpApi and DataForSEO goes through the two line by line.
  2. No code at all, one keyword at a time. SerpApi with its Google Sheets add-on, at $25 a month for 1,000 searches, which is the fastest way to see an overview in a cell and the slowest way to build a history. Our score: 4.3 out of 10, held down by the raw payload and the resale clause. cloro sits nearby at $30 a month with 250 or more locations and a documented collection method, scoring 7.4.
  3. Columns that need no formulas. API for GEO, our editorial pick, at $13 per 1,000 answers down to $7 at its largest tier, pay as you go with no published minimum, and 9.0 out of 10, the best score of the 55 APIs this site rates. Said plainly, that is about five times DataForSEO's live rate per request, and four of its ten engines, Gemini, Google AI Overviews, DeepSeek and Meta AI, plus its webhooks, OpenAPI spec and official SDKs, were confirmed in our test of October 26, 2026 rather than documented on apiforgeo.com.

Our ranking of APIs for Google AI Overviews scores all of them on the same four criteria, and the ranking for enterprise brand teams weights the ones that return presentable figures. The duels API for GEO vs DataForSEO and API for GEO vs cloro compare them field by field, and our GEO report guide covers the pipeline for teams that have outgrown a spreadsheet.

Frequently asked questions

Can I pull Google AI Overviews into Google Sheets without writing code?

Yes, through a vendor add-on. SerpApi publishes a Google Workspace add-on called SerpApi, Search Engine Results and Ranks, which adds sheet functions including `SERPAPI_RESULT()` and `SERPAPI_RANK`, and you install it from Extensions, then Add-ons, then Get add-ons, and paste your API key into its settings. The formula `=SERPAPI_RESULT("engine=google&q=drop shipping&google_domain=google.com", "ai_overview.text_blocks")` returns the overview blocks as a JSON string, which a short Apps Script custom function then parses into readable text. The limit is that a cell formula cannot keep a history: it recalculates in place, so a dated row per check still needs a script.

Does IMPORTDATA work with an AI Overviews API?

No. Google's reference for `IMPORTDATA` states that it "imports data from a given URL in .csv (comma-separated value) or .tsv (tab-separated value) format", and every AI Overviews API we checked on October 23, 2026 answers in JSON. SerpApi can return `output=html` or `output=md` on its `google_ai_overview` engine and DataForSEO returns a `markdown` field, but neither emits CSV. The same applies to `IMPORTXML` and `IMPORTHTML`, which parse a web page rather than an authenticated API response, and none of the IMPORT functions can send an API key in a header.

Why does my spreadsheet formula time out when it calls an AI Overviews API?

Because of the 30-second ceiling on custom functions. Google documents that "a custom function call must return within 30 seconds", after which "the cell displays `#ERROR!`" with the note "Exceeded maximum execution time (line 0)". One AI Overview request runs well past that in the asynchronous case: cloro publishes a "typical latency of 30 to 60 seconds end-to-end and no caching layer", and API for GEO's own synchronous example carries a 90-second timeout. Move the call into an ordinary function on a time-driven trigger, where the limit is 6 minutes per execution.

How much does a month of AI Overviews tracking in Google Sheets cost?

For 200 keywords checked once a week, which is 800 requests, the published rates on October 23, 2026 give $2.20 with DataForSEO's live Google SERP endpoint, $10.40 with API for GEO at $0.013 a credit, $30 on cloro's Lite plan and $75 on SerpApi's Developer plan. The two subscription figures are plan prices rather than usage: the same 800 requests consume about $4.48 of cloro credits and about $16.50 of SerpApi quota. Google Sheets and Apps Script add nothing, since 1,100 URL Fetch calls a month sit far under the 20,000 a day allowed on a consumer account.

Which API fills a share of voice column for AI Overviews without arithmetic in the sheet?

API for GEO, our pick after hands-on testing by Mathias C. Its response carries `shareOfVoice`, `avgPosition` and a sentiment score per entity alongside `sources[]` with `url`, `domain`, `category` and `mentionsBrand`, so each figure maps to one spreadsheet column, at $13 per 1,000 answers down to $7 at its largest tier, pay as you go with no published minimum. SerpApi, DataForSEO and cloro all return the overview text and its references with no brand detection, position or share of voice field, which leaves alias matching and the division to your own script.

How many AI Overviews rows fit in one Google Sheet?

Google's file size page allows "up to 20 million cells or 100 MB for spreadsheets that are created in or converted to Google Sheets". One row per cited source, at 12 columns and roughly 8 references per overview, gives about 57,600 cells a month for 600 collected overviews, or around 690,000 cells a year, which is about 3% of the ceiling. The 100 MB limit bites first if you also store the full overview text in a cell, so keep the long `markdown` field in a separate tab you can prune.