Check Keyword Rankings Free with Google API (2026)

Do not index

If you're searching for how to check your keyword rankings free with Google API, you probably fall into one of three camps. You want to see where your own site ranks without paying for a third-party tracker. You want to automate that check in Google Sheets or Python. Or you just want a straight answer to a messy question: does Google actually give you a real rank-tracking API, or not?

This guide gives you the honest answer, the right API, the exact limitations, and a free setup you can copy and run today. If you also want a broader look at how to track Google ranking across all your pages, or you're comparing this free approach against the best keyword rank checking tools available, we've got those covered too.

Does Google Have a Free Ranking API? (The Real Answer)

Let's cut through the confusion right away.

If you want to check rankings for your own verified site, the official free option is the Search Console API. It gives you queries, clicks, impressions, CTR, and average position for any property you have access to in Google Search Console. It's free, but it requires OAuth 2.0 authentication and Search Console permission on the property. You can read Google's pricing page for the Search Console API to confirm: all use is free of charge.

If you want a general "Google rankings API" for any domain on the public SERP, Google doesn't offer that. The other API people usually find is the Custom Search JSON API, and it works against a Programmable Search Engine, not against Google's normal organic rankings. It's also closed to new customers and existing customers must transition off it by January 1, 2027.

Search Console "position" isn't the exact rank you see when you Google something. Google defines it as the average topmost position your site occupied across impressions, and Google explicitly warns that live results vary by time, place, device, and search history.

And here's the 2026 update that matters. Google now counts AI surfaces in Search Console data. Clicks, impressions, and position for AI Mode follow standard methodology, and AI Overviews occupy a single position with all links in that overview assigned that same position. Google documents this directly in their Search Console help pages.

That's the core truth. Everything else in this guide is about using that truth well.

What "Ranking" Actually Means (And Why Most People Get It Wrong)

Most people think a ranking is a single fixed number. "I rank #6 for this keyword." That mental model is too simple. Understanding what page ranking actually means and how Google's systems compute it is the foundation for interpreting any data you pull from the API.

A real Google ranking is the result of many different searches from many different users across:

Devices (desktop, mobile, tablet)

Locations (country, state, city)

Times of day

Result types and SERP features (AI Overviews, carousels, image blocks, news blocks)

Personalization and search history

So there are really two different things people call "ranking":

1. A live SERP snapshot. This is what you see when you manually search a keyword in your browser. It's one moment, one device, one location, one context.

2. An aggregated performance signal. This is what Search Console gives you: impressions, clicks, CTR, and average position across many real searches.

For SEO decisions, the second one is almost always more useful. One manual search is an anecdote. Search Console is a dataset. Google even says that you may not see your site when you repeat a query manually because results vary by time, place, device, and recent search history.

Understanding how to check keywords ranking properly means accepting that "rank" is a distribution, not a single number. That's why aggregated Search Console data is more useful than any one-time manual lookup.

That's why "check keyword rankings with Google API" really means:

What Google's Free Ranking Data Can and Can't Do

Understanding the boundaries upfront saves you hours of frustration.

What the Search Console API Gives You

With the Search Analytics query method, you can pull:

Query (what people searched)

Page (which URL appeared)

Country and device

Date and hour (hourly data is new in 2026)

Clicks, impressions, CTR, and average position

You can filter by search type: web, image, video, news, Discover, and Google News. You can filter queries with operators like equals, contains, notContains, includingRegex, and excludingRegex. Google documents a rowLimit up to 25,000 per request and startRow for pagination.

Understanding what the Search Console API means for SEO helps you set realistic expectations before diving into the technical setup.

What the Search Console API Can't Do

It doesn't give you a clean rank checker for:

Competitors you don't control

Arbitrary domains you have no access to

Exact city-level or incognito-style SERP snapshots

Every single query Google knows about

Two big reasons for this. First, Search Console only works for properties you manage. Google requires Search Console permission on the property. Second, Search Console intentionally hides anonymized queries for privacy and may not return every possible row when query/page combinations get large.

Capability	Free Google Method	Paid Rank Tracker
Track your own site's keywords	Yes	Yes
Track competitor rankings	No	Yes
City-level SERP snapshots	No	Yes
Real clicks and impressions	Yes	No (estimated)
AI Overviews position data	Yes	Varies
Cost	Free	500+/month
Data source	Google's own data	Third-party scraping

So if your goal is free, official tracking for your own site, you're in the right place.

If your goal is public competitor rank tracking, you'll need a different approach. For a broader look at what's available, our roundup of the best keyword rank checking tools covers both free and paid options in detail.

How Search Console Calculates Average Position

This part trips up almost everyone, so let's get it right.

Google defines average position as the topmost position occupied by a link to your property in search results, averaged across the impressions where your property appeared. Google's documentation spells this out clearly.

What does that mean in practice?

If you rank #3 sometimes and #8 other times, you might see something like 5.4

If multiple pages from your site show up for the same query, Google uses the topmost one

Position reflects the result element, not how a human would visually count items on a modern SERP

This matters even more in 2026 because Google now documents how position is handled for new AI features:

AI Mode uses standard Search methodology for position

AI Overviews occupy a single position, and all links in that overview share that same position

So if you want a better decision rule than just "what's my rank?", here it is:

Improving CTR for those near-ranking keywords is one of the most valuable moves you can make. Our guide on how to improve click-through rate walks through the specific tactics that actually work.

How to Check Rankings Without Writing Any Code

Before touching the API, try the simplest approach first. Open Google Search Console and use the Performance report. Here's what the actual Google Search Console homepage looks like when you navigate there:

This is still the fastest way to gut-check what's happening with your rankings:

① Open Search results in Search Console

② Turn on Average position, Impressions, and Clicks (toggle them at the top)

③ Go to the Queries tab

④ Filter by page, country, device, or query as needed

⑤ Compare date ranges if you want to spot movement over time

Two caveats that matter here. The Queries table in the UI shows up to 1,000 top queries and omits rare queries for privacy. And the default view is the past 3 months, so if you're trying to spot a short-term change, adjust the date range explicitly.

If all you need is a quick answer, the UI is enough. If you want automation, keep reading.

For teams that want to go deeper, learning how to use Google Analytics alongside Search Console creates a much more complete picture of your traffic and performance.

Free Keyword Ranking Setup: Google Sheets + Apps Script

This is the sweet spot for most people who want to check keyword rankings free with Google API.

Why? Because it's:

Free (no subscriptions, no API costs)

Easy to share (it's a Google Sheet your team can access)

Easy to schedule (Apps Script triggers run daily without you doing anything)

Good enough for most sites (pulls up to 25,000 queries per request)

Built on Google's official data (not scraped, not estimated)

Google recommends pulling performance data daily, one day at a time, and notes that data is typically available after 2 to 3 days. That's exactly how a lightweight free tracker should work.

What This Script Does

The Apps Script below:

Pulls one day of Search Console query data

Appends it to a Google Sheet

Stores query, clicks, impressions, CTR, and average position

Can be triggered daily on a schedule

Builds your own free keyword ranking history over time

What You Need Before Running It

→ A Google account with access to the site in Search Console

→ A property identifier like sc-domain:example.com or https://www.example.com/

→ Apps Script permission to use Sheets, external requests, and Search Console read-only scope

The Apps Script Code

function appendDailyKeywordRankings() {
  const siteUrl = 'sc-domain:example.com'; // Or: https://www.example.com/
  const searchType = 'web';
  const rowLimit = 25000;
  const tz = 'America/Los_Angeles';

  // Google says Search Console data is usually available after 2-3 days.
  // Pulling 3 days back avoids most incomplete-data headaches.
  const targetDateObj = new Date();
  targetDateObj.setDate(targetDateObj.getDate() - 3);
  const targetDate = Utilities.formatDate(targetDateObj, tz, 'yyyy-MM-dd');

  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const sheetName = 'GSC_Rankings';
  const sheet = ss.getSheetByName(sheetName) || ss.insertSheet(sheetName);

  if (sheet.getLastRow() === 0) {
    sheet.appendRow([
      'date',
      'search_type',
      'query',
      'clicks',
      'impressions',
      'ctr',
      'avg_position'
    ]);
  }

  const endpoint =
    'https://www.googleapis.com/webmasters/v3/sites/' +
    encodeURIComponent(siteUrl) +
    '/searchAnalytics/query';

  const token = ScriptApp.getOAuthToken();
  let startRow = 0;

  while (true) {
    const payload = {
      startDate: targetDate,
      endDate: targetDate,
      dimensions: ['query'],
      type: searchType,
      rowLimit: rowLimit,
      startRow: startRow
    };

    const response = UrlFetchApp.fetch(endpoint, {
      method: 'post',
      contentType: 'application/json',
      headers: {
        Authorization: 'Bearer ' + token
      },
      payload: JSON.stringify(payload),
      muteHttpExceptions: true
    });

    if (response.getResponseCode() !== 200) {
      throw new Error(response.getContentText());
    }

    const data = JSON.parse(response.getContentText());
    const rows = data.rows || [];

    if (!rows.length) break;

    const values = rows.map(row => [
      targetDate,
      searchType,
      row.keys[0],
      row.clicks,
      row.impressions,
      row.ctr,
      row.position
    ]);

    sheet
      .getRange(sheet.getLastRow() + 1, 1, values.length, values[0].length)
      .setValues(values);

    if (rows.length < rowLimit) break;

    startRow += rowLimit;

    // Search Console API can page up to the practical daily cap.
    if (startRow >= 50000) break;
  }
}

Manifest Scopes

If you use explicit scopes in appsscript.json, include these:

{
  "oauthScopes": [
    "https://www.googleapis.com/auth/spreadsheets",
    "https://www.googleapis.com/auth/script.external_request",
    "https://www.googleapis.com/auth/webmasters.readonly"
  ]
}

This works because Apps Script can call external APIs with UrlFetchApp, and ScriptApp.getOAuthToken() provides the current user's OAuth token for Google API calls. The external request scope is required for UrlFetchApp.

How to Set It Up (6 Steps)

① Create a new Google Sheet

② Open Extensions then Apps Script

③ Paste the code above

④ Replace sc-domain:example.com with your actual property identifier

⑤ Run it once and authorize when prompted

⑥ Add a daily time trigger (under Triggers in Apps Script) to automate it

Now you've got a free daily keyword ranking log that grows over time. For sites built on WordPress, combining this data with our guide on how to add keywords in WordPress without plugins gives you a complete on-page plus analytics workflow.

Why This Beats Manual Rank Checking

Because it matches how Google recommends querying performance data: one day at a time, daily, based on the site's real Search Console data, without relying on fragile browser-based checks.

Once you have this historical data flowing, you'll want to pair it with a proper SEO keyword ranking report process so you can actually act on what you're seeing rather than just collecting numbers.

How to Track a Single Keyword with a Query Filter

If you only care about one specific keyword, add a filter on the query dimension. Here's the request body pattern:

{
  "startDate": "2026-03-01",
  "endDate": "2026-03-28",
  "dimensions": ["date"],
  "type": "web",
  "dimensionFilterGroups": [
    {
      "groupType": "and",
      "filters": [
        {
          "dimension": "query",
          "operator": "equals",
          "expression": "check keyword rankings"
        }
      ]
    }
  ]
}

Google supports filters like equals, contains, notContains, notEquals, includingRegex, and excludingRegex. The full Search Analytics query reference documents all available operators.

This is the cleanest way to graph one keyword's position and impressions over time.

Before setting up this filter, it helps to understand how to track Google ranking at a strategic level, because knowing which keywords deserve individual monitoring versus which are better analyzed in bulk will save you significant time.

Python Alternative: Pull Keyword Rankings Programmatically

If you prefer Python over Apps Script, Google's own Search Console quickstart shows the correct setup:

Service name: searchconsole

Version: v1

Scope: https://www.googleapis.com/auth/webmasters.readonly

Here's a minimal example that pulls top queries from the last 28 finalized days and prints "striking distance" opportunities:

from datetime import date, timedelta
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build

SCOPES = ["https://www.googleapis.com/auth/webmasters.readonly"]
SITE_URL = "sc-domain:example.com"  # Or https://www.example.com/

def get_service():
    flow = InstalledAppFlow.from_client_secrets_file("credentials.json", SCOPES)
    creds = flow.run_local_server(port=0)
    return build("searchconsole", "v1", credentials=creds)

def fetch_queries(service, site_url):
    end_date = date.today() - timedelta(days=3)
    start_date = end_date - timedelta(days=27)

    request = {
        "startDate": start_date.isoformat(),
        "endDate": end_date.isoformat(),
        "dimensions": ["query"],
        "type": "web",
        "rowLimit": 25000,
        "startRow": 0
    }

    all_rows = []

    while True:
        response = service.searchanalytics().query(
            siteUrl=site_url,
            body=request
        ).execute()

        rows = response.get("rows", [])
        if not rows:
            break

        all_rows.extend(rows)

        if len(rows) < request["rowLimit"]:
            break

        request["startRow"] += request["rowLimit"]

        if request["startRow"] >= 50000:
            break

    return all_rows

def main():
    service = get_service()
    rows = fetch_queries(service, SITE_URL)

    print("query\timpressions\tclicks\tctr\tavg_position")
    for row in rows:
        query = row["keys"][0]
        impressions = row["impressions"]
        clicks = row["clicks"]
        ctr = row["ctr"]
        position = row["position"]

        # Example filter: meaningful impressions, but not yet top 3
        if impressions >= 100 and 5 <= position <= 20:
            print(f"{query}\t{int(impressions)}\t{int(clicks)}\t{ctr:.2%}\t{position:.2f}")

if __name__ == "__main__":
    main()

This script uses the official Search Console API flow and the Python quickstart guide documented by Google.

If you want to take this further, our guide on how to use Python for NLP and semantic SEO shows how to enrich your keyword data with entity analysis and semantic clustering. That's a powerful next step once you have the raw ranking data flowing.

For teams exploring programmatic SEO, this API pattern is also the foundation for building scalable rank monitoring pipelines that can cover thousands of URLs simultaneously.

The 2026 Feature Most People Miss: Hourly Ranking Data

In April 2025, Google added hourly data to the Search Analytics API. Most people haven't caught up yet.

You can now analyze up to 10 days of data with an hourly breakdown, which is wider than Search Console's product interface hourly view. Google introduced a new HOUR dimension and a HOURLY_ALL data state for this. Google's announcement post covers the details.

This is useful for answering questions like:

Did this new article start getting traction today?

Did rankings or clicks change right after a deploy?

Are brand terms or launch terms spiking at specific times?

If you want to control data freshness, Google documents three dataState values in the Search Analytics query reference:

dataState value	What it means
`final`	Finalized data (stable, reliable)
`all`	Includes fresh, possibly incomplete data
`hourly_all`	Hourly data, which may also be partial

That means you can choose between stable reporting and early signals depending on what you need.

5 Limitations of Free Rank Checking You Should Know

This is where most bad ranking guides fall apart. They teach you how to pull the data but skip how to interpret it honestly.

1. Search Console Data Is Sampled, Not Complete

Google says the API is bounded by internal limitations and doesn't guarantee all data rows. Google's deep-dive documentation explains two major reasons totals and row-level exports can differ: anonymized queries are omitted for privacy, and daily data row limits apply to heavy exports.

2. The UI and API Don't Show the Same Amount of Data

This catches people off guard constantly.

Interface	Row Limit
Search Console UI (query table)	Up to 1,000 top queries
Search Analytics API / Looker Studio	Up to 50,000 rows per day, per site, per search type
Bulk export to BigQuery	No daily row limit

The API supports pagination with rowLimit up to 25,000 and startRow for traversing larger datasets.

3. Granular Queries Can Drop Data

Google explicitly warns that when you group by page and/or query, some data may be dropped. The more granular the request, the more likely you are to hit tradeoffs.

4. Dates Use Pacific Time

The API's startDate and endDate are interpreted in PT, and metadata for incomplete dates is returned in America/Los_Angeles time. If your team works in another timezone and you schedule daily pulls, this matters a lot.

5. Search Console Data Isn't Real-Time

Google recommends daily one-day queries and says data is typically available after 2 to 3 days. If you query "yesterday" and assume it's final, you're building a noisy tracker.

When to Scale Up from Google Sheets to BigQuery

If your site is large (think thousands of pages and millions of impressions), the free Google Sheets setup will eventually feel cramped. That's where Search Console bulk export to BigQuery becomes the better architecture.

Google says bulk export:

Sends a daily data dump to BigQuery

Includes all performance data except anonymized queries

Is not affected by the daily data row limit

Is especially useful for very large sites (small and medium sites usually get enough data through the UI, Looker Studio, or the Search Analytics API)

What Does BigQuery Cost?

Google Search Console says bulk export data is subject to BigQuery storage and query costs, but there's a free usage level. The first 1 TiB of query data processed per month is free, then on-demand pricing is $6.25 per TiB processed.

That means many small and medium sites can experiment cheaply, and sometimes effectively for free.

SQL Query: Find Striking-Distance Keywords in BigQuery

Google's sample queries documentation shows that in bulk export, anonymized queries are stored as a zero-length string, and the exported sum_top_position metric is zero-based (which is why Google adds + 1.0 in their sample formula).

Here's a practical query you can run right now:

WITH ranked_queries AS (
  SELECT
    query,
    SUM(impressions) AS impressions,
    SUM(clicks) AS clicks,
    SAFE_DIVIDE(SUM(clicks), SUM(impressions)) AS ctr,
    ((SUM(sum_top_position) / SUM(impressions)) + 1.0) AS avg_position
  FROM `your_project.searchconsole.searchdata_site_impression`
  WHERE data_date BETWEEN DATE_SUB(CURRENT_DATE(), INTERVAL 28 DAY) AND CURRENT_DATE()
    AND search_type = 'WEB'
    AND query != ''
  GROUP BY query
)
SELECT *
FROM ranked_queries
WHERE impressions >= 100
  AND avg_position BETWEEN 5 AND 20
ORDER BY impressions DESC;

This SQL surfaces the exact keywords most sites should work on first: high impressions, decent position, room to improve.

For broader website analysis beyond just keyword positions, our guide on website traffic analysis covers how to pull all your performance signals into a coherent picture.

Common Mistakes That Make Free Rank Checking Look Broken

If your free rank data seems "wrong," one of these is usually the culprit.

Mistake 1: Treating manual Google searches as the truth. Your manual search is one moment for one user context. Search Console is an aggregate across many real impressions. If those two don't match perfectly, that's normal. Google says so directly.

Mistake 2: Thinking average position equals a fixed rank. It doesn't. It's an average of the topmost position your site occupied across all impressions for that query. Google's help documentation makes this distinction clear.

Mistake 3: Filtering by query, then wondering why totals don't add up. Anonymized queries are omitted from tables and disappear from filtered views, even though they can still be included in chart totals. Google's data deep-dive explains this in detail.

Mistake 4: Pulling too much detail too early. If you group everything by page + query + country + device and expect perfect completeness, you're fighting the product. Google explicitly warns that page/query-heavy requests can lose data rows.

Mistake 5: Using the wrong Google API entirely. If you use the Custom Search JSON API because it sounds like "Google Search API," you're solving a different problem. It's for a Programmable Search Engine, not for official organic rank tracking on the public Google SERP.

How to Turn Ranking Data into SEO Wins

Checking rankings is not the goal. Finding your actual opportunities is the goal.

Here's the workflow that actually produces results:

Pull queries weekly or daily using the methods above

Sort by impressions first (this tells you where Google already thinks you're relevant)

Filter for average positions between 5 and 20 (your striking-distance zone)

Group by landing page to see which pages serve which clusters of queries

Decide your action: update the page, improve CTR with better titles/descriptions, or create supporting content

Watch what moves over the next 2 to 6 weeks

A lot of teams obsess over "Did I move from #7 to #6?" That's too narrow.

A better question is:

That's where easy wins live. And this is exactly where the free Google API method shines: it shows you real impressions and real position data for your actual site, straight from Google's own systems.

When you identify those striking-distance keywords, the next question is what to do about them. Finding low competition keywords is a complementary approach: you use Search Console to spot where you're close, then verify those terms have the right volume and competition profile before investing in content.

A strong content gap analysis helps you understand which topics your competitors rank for that you don't. Layering that with your striking-distance data gives you a prioritized content roadmap.

If you want to turn those "almost ranking" queries into a content plan, Outrank's Blog Keyword Generator is a solid next step because it expands topic ideas from your site context.

For deeper planning, check out our guides on keyword research tutorial, how to find keyword search volume, and the best keyword rank checking tools for 2026.

When the Free Google Method Is Enough (And When It Isn't)

Use the Free Google Method If:

You want rankings for your own site

You care about real impressions and clicks, not vanity position checks

You want a free, reliable baseline built on official Google data

You're comfortable using Sheets, Apps Script, Python, or BigQuery

Use a Dedicated Rank Tracker If:

You need competitor tracking across multiple domains

You need exact SERP snapshots by city, device, or location

You need alerts, share-of-voice, or local pack tracking

You want to monitor keywords your site hasn't appeared for yet

That's the clean dividing line. Google's free tools are excellent for owned-site performance measurement. They're not a full substitute for every use case in professional rank tracking.

If you're evaluating your options on the paid side, our comparison of Semrush alternatives breaks down which tools offer genuine value versus which are largely redundant with what Google already gives you free.

And if you're finding that the real bottleneck isn't tracking your rankings but actually doing something about them (creating content, building authority, staying consistent), that's a different problem entirely. Our content creation workflow guide and resources on how to scale content marketing address exactly that execution gap.

Turn Ranking Data into Action with Outrank

You just learned how to check your keyword rankings for free. That's the measurement side. But measurement without action is just a dashboard you stare at.

The pattern we see over and over is this: someone sets up free rank tracking, identifies 50 striking-distance keywords, and then... nothing happens. Writing 50 optimized articles is a massive undertaking. Finding the right keywords, researching intent, drafting content, optimizing for SEO, and publishing it consistently takes a full-time team.

That's exactly why we built Outrank, one of the best AI SEO tools for turning keyword research directly into published content.

Outrank is an SEO automation platform with a full pipeline: finding keyword opportunities through AI-driven research, generating long-form articles up to 3,000 words, optimizing them for search, and publishing directly to your CMS (WordPress, Webflow, Shopify, Framer, and more). Learn more about the AI SEO content generator capabilities at the core of the platform.

The part that makes this different from just another AI writer is the authority-building layer. Outrank includes a Backlink Exchange network that builds relevant links between sites, plus a directory submission service covering 350+ directories. Content velocity plus authority building, running on autopilot.

For teams wondering whether to build internal content resources or automate, our guide on SEO automation tools covers the landscape of what's available and what actually gets results.

So the workflow becomes: check your rankings with the free Google API, identify your opportunities, and let Outrank handle the content execution at scale.

Skip the Manual Work Entirely: Outrank Agency

Maybe you've read this guide and you're thinking, "This is great, but I don't have time to set up API scripts, analyze striking-distance keywords, and write 30 articles a month."

That's fair. And that's exactly what Outrank Agency was built for.

Outrank Agency is a done-for-you SEO content service. You get a personal content manager, industry experts, and SEO specialists working every article from research to publication. It's not freelancers you have to manage, and it's not raw AI content that Google ignores.

What You Get Each Month

30 expert-crafted articles generated and published on autopilot

Full keyword research and competitor gap analysis by SEO specialists

Content calendar planned 3 months ahead (you approve or just let it run)

SEO specialist optimization for every article: structure, LSI keywords, internal links, on-page signals

Dedicated Slack channel for fast communication and revisions

Direct CMS publishing: wake up and your new article is already live

High DR backlinks built through the Backlink Exchange network

Every article gets reviewed and refined by an industry specialist who checks facts, fixes inaccuracies, and makes sure the content is genuinely expert-level. Not AI slop. Not outsourced to random freelancers. If you've been looking for organic SEO services that combine AI speed with human quality, this is what that looks like in practice.

What It Costs

$1,499 per month. Only 5 new clients accepted per month to protect quality. No contracts. Cancel anytime.

What Clients Are Saying

Free Google API vs. Outrank Agency

ㅤ	Free Google API Method	Outrank Agency
Ranking data	Yes (your own site)	Yes + expert interpretation
Content creation	You do it	30 articles/month, done for you
Keyword research	Manual or basic tools	Expert-level gap analysis
SEO optimization	Manual	Specialist-optimized every article
Publishing	Manual	Direct CMS, daily delivery
Authority building	None	Backlink Exchange + directory submissions
Time investment	10-20+ hours/week	Nearly zero
Cost	Free (your time)	$1,499/month

If you want to see how this would work for your business, book a demo with our team. Or check out everything included at outrank.so/agency.

Frequently Asked Questions

Is the Google Search Console API Free?

Yes. Google's pricing page for the Search Console API confirms all use is free of charge. You'll still need a Google Cloud project for OAuth credentials, but the API itself has no cost.

What Are the Search Console API Usage Limits?

Google documents limits including 1,200 queries per minute per site, 1,200 queries per minute per user, and 40,000 queries per minute / 30,000,000 queries per day per project, along with separate load quotas. The full usage limits documentation has the current numbers.

How Fresh Is the Ranking Data?

Google recommends daily one-day pulls and says Search Console data is typically available after 2 to 3 days. If you use the all or hourly_all data state, you can get fresher but potentially incomplete data.

Can I Use This to Track Competitor Rankings?

Not with the official Google method. Search Console requires permission on the property you query. If you need competitor data, you'll need a third-party rank tracking tool, or you can use Outrank's keyword research tools to identify competitive opportunities from a different angle.

Does Search Console Include AI Overviews and AI Mode Data?

Yes. Google documents how clicks, impressions, and position are counted for both AI Overviews and AI Mode in Search Console's position documentation. This is especially relevant in 2026 as AI features become more prominent in search results.

How Many Rows Can I Export from Search Console?

It depends on which interface you use:

Search Console UI: up to 1,000 rows in the query table

Search Analytics API / Looker Studio: up to 50,000 rows per day, per site, per search type (with pagination using rowLimit up to 25,000 per request)

Bulk export to BigQuery: not affected by the daily row limit

What's the Difference Between Search Console API and Custom Search JSON API?

They solve completely different problems. The Search Console API gives you performance data (clicks, impressions, position) for your own verified sites. The Custom Search JSON API queries a Programmable Search Engine, not Google's organic search results. It's also sunsetting for new users, with existing customers required to transition by January 2027.

Do I Need Coding Skills to Check Keyword Rankings for Free?

Not necessarily. The Search Console web interface gives you ranking data with zero code. If you want automation (daily pulls, historical tracking, striking-distance analysis), you'll need basic comfort with Google Sheets Apps Script or Python. The code examples in this guide are copy-pasteable and well-commented. If you prefer a completely no-code approach to automating your content and SEO, there are platforms designed to handle everything without touching any scripts.

How Accurate Is Search Console Position Data?

It's as accurate as Google's own systems report it. The position shown is the average topmost position your site occupied across real impressions for that query. It won't match a single manual search because manual searches reflect one context at one moment. Search Console reflects the aggregate, which is more useful for SEO decisions.

Can I Use This Method for Local SEO Tracking?

Partially. You can filter Search Console data by country, but not by city or neighborhood. For hyperlocal tracking (like "dentist near me" for a specific zip code), you'll need a dedicated local SEO tool that can simulate searches from specific locations. Our guide on SEO for small businesses covers how local operators should approach their tracking and content strategy given these limitations.

What to Do Next with Your Free Ranking Data

You now have everything you need to check your keyword rankings free with Google API in 2026. The Search Console API is genuinely powerful, it costs nothing, and it gives you data straight from Google's own systems.

Start with the Google Sheets setup if you want something running in 15 minutes. Move to Python if you need more flexibility. Graduate to BigQuery when your data outgrows spreadsheets.

But don't let rank tracking become a spectator sport. The whole point of knowing where you rank is figuring out what to do about it. Identify your striking-distance keywords, create better content for them, and build the authority that pushes you from page two into the top results.

Building topical authority around your core subject matter is one of the most durable SEO investments you can make. It's what transforms individual rankings into sustained organic growth across your entire keyword universe.

Understanding how to rank on Google goes well beyond rank tracking: it requires consistently publishing well-optimized SEO content and building quality backlinks.

Monitoring your website traffic alongside your keyword data gives you a complete picture, so you can catch opportunities before competitors do.

If you want that execution layer handled for you, Outrank's SEO automation platform handles the entire pipeline from keyword research to published content. And if you want the full done-for-you experience with human experts refining every piece, Outrank Agency is built for exactly that. Book a demo and see how it works.

The free tools are excellent. What you do with the data is what separates sites that grow from sites that just track numbers.