All posts
November 13, 2026·9 min read

Google Search Console API row limit: why you lose rows

Gaurav Singh
Gaurav Singh
Founder, ad-vertly
Google Search Console API row limit: why you lose rows

The Google Search Console API returns 25,000 rows per request and 1,000 by default, so you page through results by raising startRow by 25,000 until a call comes back with zero rows. That fixes page size. It doesn't fix the three things that actually delete your rows: a 50,000 rows per day per search type ceiling, anonymized long-tail filtering, and unstable ordering between pages.

The Search Console API limits, in one list

Most guides stop at the 25,000 figure and a startRow loop. That answer is correct, and people still end up with half a dataset, because the request limit and the data limit are different ceilings and only one of them is where you would look first. Six numbers decide how much you can pull: four from Google's API reference and usage limits pages, both last updated 28 August 2025, and two from what people measure once they're past the tutorial.

  • rowLimit tops out at 25,000. That's the documented maximum for a single searchAnalytics response, and it's the number everyone quotes.
  • Leave rowLimit unset and you get 1,000 rows. That default is why integrations return suspiciously round totals.
  • 50,000 rows per day, per search type, is the ceiling on the data itself, sorted by clicks.
  • 1,000,000 rows is the most any single query will hand back, so the per-day budget multiplies but the per-query total doesn't.
  • 2 to 3 days is the delay before fresh clicks become queryable. A job asking for yesterday returns an empty or partial result.
  • 1,200 queries per minute per site and per user is the throttle, with 40,000 per minute and 30,000,000 per day allowed per project.

The quota you're most likely to trip isn't the per-minute one. It's the load quota, which Google measures in ten minute and one day buckets, and which gets expensive the moment you group or filter by page and query in the same request. Google states plainly that queries grouping or filtering by page and query string are the most expensive ones you can send.

Why do you lose rows even when you paginate correctly?

Three separate mechanisms delete rows from a result set that looks complete when you print its length.

  1. The per-day data ceiling. Search Console sorts by clicks descending and keeps the top 50,000 rows per search type per day. Query 90 days with page and query dimensions and you're competing for a fixed daily budget, not reading a table.
  2. Anonymization. Google filters out low-volume queries for privacy, and the filtering bites harder as you add dimensions. Add device and country to a request already carrying page and query, and long-tail rows disappear between runs.
  3. Unstable ordering across pages. There is no sort parameter, rows arrive clicks descending with no tiebreaker, so equal-click rows can move between calls.

The third is the one almost nobody writes about, and it's the one that hands you duplicates and gaps inside the same pull.

The missing secondary sort breaks naive pagination

Google's own pagination recipe is to re-run the same query with startRow incremented until a page returns zero rows. That recipe assumes a stable ordering, and the API never promises one.

The API does not have a sort option, the data is always delivered sorted by clicks, descending. There is no secondary sort, and the order of multiple rows with the same number of clicks may be random. Source: Analytics Edge, Download Over 25,000 Rows From Google Search Console API, 18 July 2025.

The long tail is exactly where clicks flatten out, so the end of every page is a cluster of rows with identical click counts. Page two can open with a row page one already gave you, and the row that should have been next is simply absent.

The fix isn't a bigger rowLimit. It's deduplicating on the dimension key as you page, and treating a short page as a signal to stop rather than as permission to trust the boundary.

How do you paginate searchAnalytics in Python?

Two layers. First the request, shaped so you don't hit a ceiling by accident.

  1. startDate and endDate. Query one day at a time, which is what Google recommends. A one day window keeps you under the load quota and gives every day its own 50,000 row budget.
  2. dimensions. Use page and query if you need the page-level split. Drop to query alone when you want more complete counts and don't need to know which page earned them.
  3. type. Enumerate web, image, video and news as separate calls. Each search type gets its own daily rows.
  4. rowLimit. Set 25000 explicitly. Never leave it out, and never pass a larger number expecting more.
  5. startRow. Zero on the first call, then plus 25,000. Stop when a response returns an empty rows array.
  6. dataState. Leave it at final for reproducible numbers. Adding all pulls fresh, still-settling data that will change under you.

Second layer is the loop, and it only needs five lines to survive the missing tiebreaker:

  • seen = set() before you enter the loop
  • row_id = joined response keys, per row
  • if row_id in seen: skip it, otherwise add it and keep the row
  • startRow += 25000 and re-send the same request
  • break when the response returns zero rows

That's the whole repair. The dedupe pass removes the repeats the absent tiebreaker creates. Expect a small number of genuinely unrecoverable rows at the tail regardless, because anonymization takes a cut that pagination can't buy back.

The 50,000 row ceiling is per day, not per query

The most common misreading of the documentation is that 50,000 is a total budget. It's a per-day figure, per search type.

A 30 day window can therefore expose 50,000 multiplied by 30, or 1,500,000 rows, subject to the 1,000,000 row cap on any single query. Build one request for the whole month and you didn't lose the month to a bug. You lost it to a ceiling you didn't know existed.

The design rule that follows: one call per day per search type, keep the results locally, and join afterwards. It's slower than one big request and it returns more, and it also gives you a stable partition to re-run when a single day fails instead of re-pulling everything.

What gets dropped: anonymized long-tail queries

Search Console isn't a complete log. It stores top rows rather than every row, and it removes queries it considers identifying. Neither behaviour is a bug you can paginate around.

The asymmetry matters more than the filtering. Over the same window, the same property commonly reports more impressions when you ask for pages than when you ask for pages and queries together, because the query breakdown is where anonymization and sampling land hardest.

If you need accurate per-page totals, send aggregationType byPage with no page or query dimension in the request. You keep counts you can defend and you give up query detail, which is the opposite trade to the one most dashboards make.

If the query detail is the whole point and you need all of it, the API is the wrong instrument.

When 25,000 rows is not enough: the BigQuery bulk export

Google shipped a path around the ceiling in February 2023 and it's still underused.

The data includes all your performance data, apart from anonymized queries, which are filtered out for privacy reasons; in other words, the bulk data export is not affected by the daily data row limit. Source: Google Search Central Blog, Bulk data export, February 2023.
  • Use the API when you want one property, a recent window, and a report you'll run today.
  • Use bulk export when you want every query for every day and you plan to join it to ad spend, crawl data or an LLM pipeline.
  • Use neither when you want a one-off CSV. The Search Console interface exports 1,000 rows and that's occasionally enough.

Bulk export still drops anonymized queries, so it raises the volume ceiling without making the dataset complete. Anyone selling you all of your Search Console data is selling you a filtered subset.

How to feed clean Search Console data into a marketing agent

This matters past reporting, because an agent's judgement is only as good as the query rows it can see. A tool wired to a default rowLimit has every downstream decision made on one page of data.

That failure is silent. The agent doesn't report an empty result, it reports a confident one built on a thousand rows. We hit exactly this shape while auditing our own pipeline: a query tool with a hardcoded cap returned roughly 35 post rows, where the full pull returned 1,114 distinct queries for the same 30 day window on a 134 post site. Nothing errored. The answer was just narrower than the question.

  • Pull once, store locally, and let the agent query the store. Rate limits then apply to one daily job rather than to every agent turn.
  • Keep the raw dimension keys. Recomputing keys after a schema change is how you lose the ability to dedupe your own history.
  • Assert the row count. A pull that returns exactly 1,000 rows has very likely been truncated.

For the keyword side of the same workflow, our guide to judging a keyword before you write it covers what to do with these rows once you have them, and the rank tracking software breakdown covers the positions Search Console won't give you. If you care about AI answers rather than blue links, AI Overview rank tracking explains why impressions and citation frequency diverge.

The same principle runs through AI marketing agents for solo founders: the tool layer decides the answers, so it's worth ten minutes of plumbing. ad-vertly sits on exactly this layer, and the row limit is the cheapest part of it. Knowing which ceiling you hit is what keeps the data honest.