# Google Rank Checker - Bulk SERP Position Tracker API & MCP (`doesaiknow/google-rank-checker`) Actor

Bulk Google rank checker / SERP position tracker: today's position, ranking URL, top-3 competitors above you, SERP features (AI Overview, snippet, PAA) + search volume + MCP - one decisional row per keyword. Pay-per-use rank tracker API, no subscription. Free preview.

- **URL**: https://apify.com/doesaiknow/google-rank-checker.md
- **Developed by:** [Dawid S](https://apify.com/doesaiknow) (community)
- **Categories:** SEO tools, AI, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 rank check (per keyword × device)s

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Google Rank Checker — Bulk SERP Position Tracker API

Bulk **Google rank checking** — paste your domain + a keyword list, get **one decisional row per
keyword**: today's **position** and ranking URL, the **top-3 competitors above you**, SERP-feature
occupancy (**AI Overview** / featured snippet / People Also Ask) and estimated **search volume /
CPC** so you instantly see which lost rankings hurt financially. Check keyword rankings **without a
monthly rank-tracker subscription** — pay-per-use, **from $0.012 per keyword check**, free preview,
no monthly floor.

> **What this is — and what it is NOT.** Positions are **factual**: each row is read from a live
> Google results page observed at `checked_at` (labeled `position_source: "observed_serp"`).
> Search volume / CPC are **estimates** (labeled `volume_source: "estimated"`). This is a
> **stateless snapshot** — it tells you where you stand *now*; it does not store history or charts.
> **Re-run it (or put it on the Apify scheduler) to refresh** — daily/weekly tracking is one
> schedule away, with no state held anywhere.

### What you get

| Layer | Output | Extra cost |
|---|---|---|
| **Position** (always) | Organic rank (`position`) + absolute rank, ranking URL & title, `found` flag ("not in the top-20/50/100 checked" is an answer too) | — |
| **Who beats you** (always) | The top-3 organic competitors above your position (or the top-3 owning the SERP when you're not ranked) | included |
| **SERP features** (always) | AI Overview present + **which domains it cites**, featured-snippet owner, People-Also-Ask, local pack | included |
| **Volume enrichment** (default on) | Estimated monthly search volume, CPC, competition per keyword — prioritize losses by value | included |
| **Seed from domain** (opt-in flag) | Auto-populate the keyword list from what your domain **already ranks for** (highest volume first) | small per-keyword fee |

One run = up to **2,000 keywords**, desktop and/or mobile, any Google country/language market —
one row each, no raw SERP JSON to post-process. Choose how deep each check goes: **top-20**
(default), **top-50**, or **top-100** — deeper results pages cost proportionally more to fetch, so
they bill 2× / 4× rank-check events per keyword (the per-event price never changes).

### Quick start
```json
{ "domain": "yourdomain.com",
  "keywords": ["project management software", "team collaboration tools", "kanban board"],
  "location": "United States", "language": "English", "device": "desktop" }
````

Full URLs work too — `https://www.yourdomain.com/pricing` is normalized to `yourdomain.com`
automatically; subdomains count as ranking (blog.yourdomain.com counts for yourdomain.com).

### Output example

One row per keyword × device:

```json
[
  { "keyword": "project management software", "domain": "monday.com", "device": "desktop",
    "found": true, "position": 13, "position_absolute": 17, "serp_depth": 20,
    "ranking_url": "https://monday.com/free-project-management-software",
    "top_competitors": [
      { "position": 1, "domain": "project-management.com", "url": "https://project-management.com/top-10-project-management-software/" },
      { "position": 2, "domain": "icagile.com", "url": "https://www.icagile.com/..." },
      { "position": 3, "domain": "paymoapp.com", "url": "https://www.paymoapp.com/blog/project-management-software/" }
    ],
    "ai_overview_present": true, "ai_overview_sources": ["wrike.com", "slack.com", "monday.com"],
    "featured_snippet_domain": null, "people_also_ask_present": true,
    "search_volume": 135000, "cpc": 49.70, "volume_source": "estimated",
    "location": "United States", "checked_at": "2026-07-12 15:35:34 +00:00",
    "position_source": "observed_serp" },
  { "keyword": "team collaboration tools", "domain": "monday.com", "device": "desktop",
    "found": false, "position": null, "serp_depth": 20,
    "top_competitors": [
      { "position": 1, "domain": "getvoip.com", "url": "https://getvoip.com/blog/team-collaboration-software/" },
      { "position": 2, "domain": "microsoft.com", "url": "https://www.microsoft.com/..." },
      { "position": 3, "domain": "thedigitalprojectmanager.com", "url": "https://thedigitalprojectmanager.com/..." }
    ],
    "ai_overview_present": true, "ai_overview_sources": ["slack.com", "reclaim.ai", "youtube.com"],
    "search_volume": 301000, "cpc": 32.66, "volume_source": "estimated",
    "location": "United States", "position_source": "observed_serp" }
]
```

Real run, 2026-07-12: monday.com ranks #13 for a 135k-volume keyword and is **absent from the
top-20** for a 301k-volume, $32-CPC keyword whose AI Overview cites slack.com — that row is the
whole product.

### Use cases

- **Verify your rankings today** — exactly your keyword list, exact positions, not database
  approximations.
- **Client & audit reports** — an agency pitch audit for 200 keywords in one run, sorted by CPC.
- **Prioritize losses by value** — volume + CPC in the same row shows which drops cost real money.
- **AI Overview exposure** — see which of your keywords now carry an AI Overview and **who it cites**.
- **Scheduled tracking without a subscription** — put a run on the Apify scheduler (daily/weekly),
  pay only for the checks that run.
- **Multi-market checks** — same list evaluated in any country/language, desktop and mobile.

### Pricing

**Pay per event, no subscription.** You pay only for delivered rows — failed checks, cache hits
and empty runs are never billed per-check. A "not found in the top-N checked" row (`found: false`)
IS a delivered answer and is billed. `device: "both"` runs two checks per keyword (two live results
pages — twice the data, honestly billed as 2 events).

| Event | Fires | Price (FREE tier) |
|---|---|---|
| `actor-start` | once per run (validation + cache check) | $0.05 |
| `rank-check` | per keyword × device row delivered (volume enrichment included) | **$0.020** |
| `seed-keywords` (opt-in) | per seeded keyword delivered | $0.004 |

**SERP depth multiplies the rank-check count, not the price:** a top-20 check bills 1 event per
keyword, top-50 bills 2, top-100 bills 4 — because a deeper live results page costs proportionally
more to fetch upstream. Same per-event price on every rung.

| Depth | Events per keyword | Cost per keyword (FREE / GOLD) |
|---|---|---|
| top-20 (default) | 1× | $0.020 / $0.012 |
| top-50 | 2× | $0.040 / $0.024 |
| top-100 | 4× | $0.080 / $0.048 |

#### Volume discounts by Apify plan tier

| Event | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|
| `rank-check` | $0.020 | $0.018 | $0.015 | **$0.012** |
| `seed-keywords` | $0.004 | $0.0035 | $0.003 | **$0.0025** |

> `actor-start` stays flat across tiers. Checking **100 keywords** (desktop, top-20) costs
> **$2.05** on FREE and **$1.25** on GOLD — no seat, no keyword-quota subscription, no monthly
> minimum. **Free Apify plans:** a 25-keyword desktop top-20 preview per run (positions +
> features; volume enrichment, mobile, deeper SERPs, AI-Overview source domains and seeding are
> paid-plan features).

### How it compares

| | This actor | AccuRanker | SE Ranking | Semrush | Ahrefs |
|---|---|---|---|---|---|
| Entry price | **pay-per-use, from $0.012/check** | monthly subscription | monthly subscription | monthly subscription | monthly subscription |
| Keyword quota | **none — pay per check** | plan-limited | plan-limited | plan-limited | plan-limited |
| Self-serve API access | **✅ from the first call** (every run is an API call) | plan-gated | credit add-on | top-plan gated | top-plan gated |
| Competitors above you + AI Overview occupants in the same row | **✅** | partial | partial | partial | partial |
| History & charts | ❌ snapshot (re-run / schedule) | ✅ | ✅ | ✅ | ✅ |

Where incumbents win: if you track thousands of keywords **daily**, a flat-rate subscription gets
cheaper per check — this actor is built for **everyone else**: freelancers, agencies doing audits,
devs wiring rank data into a workflow, and anyone who refuses to pay monthly for weekly checks.

Most "rank tracker" actors on Apify either dump raw SERP JSON (you build the position diff
yourself) or scrape a SaaS frontend that breaks on redesign. This one is built on **native SEO
data APIs — zero scraping** — and returns a finished decision table.

### What it does NOT do (honest scope)

- **No history, no charts.** v1 is a stateless snapshot. Re-run to refresh; the Apify scheduler
  gives you recurring checks. (History/diff between runs is on the roadmap.)
- **Positions are data-center SERPs, not your browser.** Like every rank tracker, positions come
  from a neutral, non-personalized Google results page. Your logged-in, location-personalized
  browser may differ by a position or two — that is the category-standard caveat, not a bug.
- **Volume/CPC are estimates** for prioritization — labeled `volume_source: "estimated"`.
- **Top-100 at most.** Depth is 20 (default), 50 or 100 — deeper rungs bill proportionally more
  events because deeper results pages cost proportionally more to fetch. Beyond 100 the cost grows
  disproportionately and "not in top-100" already answers the decision question.
- **Snapshot of ranked keywords, not full keyword research.** `seedFromDomain` seeds your tracking
  list; for the complete keyword universe of any domain use our
  [Competitor Keyword Research](https://apify.com/doesaiknow/doesaiknow-competitor-keywords-apify) actor.

### FAQ

**Why is my position different from what I see in my browser?**
Personalization. Google tailors results to your history, location and device; this actor reads a
neutral data-center results page — the same methodology every professional rank tracker uses, so
numbers are comparable run-to-run.

**Is this a rank tracker with history?**
v1 is deliberately stateless: it answers "where do I stand right now?" perfectly and stores
nothing. For recurring tracking, schedule the run (Apify scheduler, cron-style) and diff the
datasets — each row carries `checked_at`.

**What does `found: false` mean?**
Your domain is not in the top-N organic results checked for that keyword in that market — N is
your `depth` input (20/50/100) and is recorded in the row as `serp_depth`. That is a real,
billable answer (and the row still shows who IS ranking and the keyword's value).

**Which markets and devices are supported?**
Any full location/language name ('United States'/'English', 'Germany'/'German', …), desktop and
mobile. One market per run; `device: "both"` checks both devices in one run.

**Do I need a subscription?**
No. Pay per delivered row; failed, cached and empty runs are never charged per-check.

**Can I run it from an AI agent?**
Yes — it's a limited-permission, MCP-ready actor (no first-run approval step), callable from AI
agents and IDEs via the Apify MCP server.

### Related actors

Part of the DoesAiKnow keyword-research & GEO/SEO suite on Apify:

- **[Keyword Metrics Pro — Google + Bing Volume, CPC & Trend](https://apify.com/doesaiknow/doesaiknow-keyword-metrics-apify)** — find the keywords worth tracking here.
- **[Competitor Keyword Research — See Any Site's Ranked Keywords](https://apify.com/doesaiknow/doesaiknow-competitor-keywords-apify)** — the full keyword list behind any competitor that outranks you.
- **[AI Keyword Clustering Tool — Topical Clustering + Bulk SERP](https://apify.com/doesaiknow/ai-keyword-clustering-tool-topical-clustering-bulk-serp)** — group your tracked list into topic clusters.
- **[Backlink Checker API — Referring Domains & Competitor Gap](https://apify.com/doesaiknow/backlink-checker-api-referring-domains-competitor-gap)** — the link profile behind their positions.
- **[AI Search Volume — GEO / AEO Keyword Research Tool & API](https://apify.com/doesaiknow/ai-search-volume-geo-keyword-research-tool-api)** — AI-search demand for your topics.
- **[AI Brand Visibility Tracker — ChatGPT, Perplexity, Gemini](https://apify.com/doesaiknow/ai-brand-visibility-tracker-chatgpt-perplexity-gemini)** — is your brand cited in AI answers?

### Disclaimer

Provided as-is for research. Positions reflect the observed results page at check time; search
volume and CPC are best-effort **estimates** for prioritization. Independent project — not
affiliated with, endorsed by, or partnered with Google, AccuRanker, SE Ranking, Semrush, or Ahrefs.

### SEO keyword cluster

google rank checker, keyword rank checker, rank tracker api, serp position checker, serp rank api,
bulk rank checker, check keyword rankings, keyword position checker, google ranking api, serp
checker, position tracking tool, rank tracking without subscription, accuranker alternative,
semrush position tracking alternative, ahrefs rank tracker alternative, se ranking alternative,
serp features tracker, ai overview tracker, ai overview checker, featured snippet checker, google
position api, keyword ranking api, bulk serp checker, website rank checker, seo rank checker,
mobile rank checker, local rank checker, pay per use rank tracker, rank checker api, mcp seo tool,
mcp server, mcp actor, model context protocol, seo api without subscription, apify mcp server.

# Actor input Schema

## `domain` (type: `string`):

The domain whose Google rankings you want to check, e.g. 'yourdomain.com'. Full URLs work too — protocol / www. / path are stripped automatically. Subdomains count as ranking (blog.yourdomain.com counts for yourdomain.com).

## `keywords` (type: `array`):

Up to 2000 keywords (paid Apify plans) to check positions for. Each keyword is normalized (lowercased, whitespace collapsed) and deduplicated before any paid call. FREE PLAN: 25-keyword preview per run, desktop only; the actor exits early with an upgrade prompt above the limit. Leave empty and enable 'Seed from domain' to auto-populate the list (paid plans).

## `location` (type: `string`):

Full location name for the Google market the positions are checked in, e.g. 'United States', 'United Kingdom', 'Germany', 'Poland'. One market per run — run again for another market. Default 'United States'.

## `language` (type: `string`):

Full language name for the market, e.g. 'English', 'German', 'Polish'. Default 'English'.

## `device` (type: `string`):

Which Google results to check: 'desktop', 'mobile', or 'both'. 'both' runs two checks per keyword (two SERPs = two rank-check fees — honestly billed, it is twice the data). FREE PLAN: desktop only. Default 'desktop'.

## `depth` (type: `integer`):

How deep to check each Google SERP: 20 (default), 50, or 100 results. Deeper SERPs cost proportionally more upstream, so they bill more rank-check events per keyword: top-20 = 1×, top-50 = 2×, top-100 = 4× (the per-event price never changes). Other values round UP to the next allowed depth (e.g. 30 → 50). FREE PLAN: fixed to top-20. If your domain is not found, the row says so relative to the depth checked (serp\_depth field).

## `includeVolume` (type: `boolean`):

Add estimated monthly search volume, CPC and competition to each keyword row so lost rankings can be prioritized by value. Included in the rank-check price — no extra fee. Paid Apify plans only (forced off on the free preview). Default true.

## `seedFromDomain` (type: `boolean`):

Auto-populate the keyword list with the keywords your domain ALREADY ranks for (highest-volume first) — 'track what you rank on' without typing a list. Extra per-seeded-keyword fee (see README pricing); charged only for seeded keywords that actually reach the dataset. Paid Apify plans only. Default false.

## `seedLimit` (type: `integer`):

Maximum number of keywords to seed from the domain (only with 'Seed from domain'). Default 100, max 500. Total keywords per run stay capped at 2000.

## `bypassRunCache` (type: `boolean`):

Skip the 24h KV Store run-cache and take a fresh live SERP snapshot. You will be charged the per-check fees again. Default false.

## Actor input object example

```json
{
  "domain": "monday.com",
  "keywords": [
    "project management software",
    "team collaboration tools",
    "kanban board"
  ],
  "location": "United States",
  "language": "English",
  "device": "desktop",
  "depth": 20,
  "includeVolume": true,
  "seedFromDomain": false,
  "seedLimit": 100,
  "bypassRunCache": false
}
```

# Actor output Schema

## `rankRows` (type: `string`):

Default dataset link. See dataset\_schema.json for per-field documentation.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domain": "monday.com",
    "keywords": [
        "project management software",
        "team collaboration tools",
        "kanban board"
    ],
    "location": "United States",
    "language": "English",
    "device": "desktop"
};

// Run the Actor and wait for it to finish
const run = await client.actor("doesaiknow/google-rank-checker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "domain": "monday.com",
    "keywords": [
        "project management software",
        "team collaboration tools",
        "kanban board",
    ],
    "location": "United States",
    "language": "English",
    "device": "desktop",
}

# Run the Actor and wait for it to finish
run = client.actor("doesaiknow/google-rank-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domain": "monday.com",
  "keywords": [
    "project management software",
    "team collaboration tools",
    "kanban board"
  ],
  "location": "United States",
  "language": "English",
  "device": "desktop"
}' |
apify call doesaiknow/google-rank-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=doesaiknow/google-rank-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Rank Checker - Bulk SERP Position Tracker API & MCP",
        "description": "Bulk Google rank checker / SERP position tracker: today's position, ranking URL, top-3 competitors above you, SERP features (AI Overview, snippet, PAA) + search volume + MCP - one decisional row per keyword. Pay-per-use rank tracker API, no subscription. Free preview.",
        "version": "0.1",
        "x-build-id": "eCXaWZCfPFecNdTPK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/doesaiknow~google-rank-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-doesaiknow-google-rank-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/doesaiknow~google-rank-checker/runs": {
            "post": {
                "operationId": "runs-sync-doesaiknow-google-rank-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/doesaiknow~google-rank-checker/run-sync": {
            "post": {
                "operationId": "run-sync-doesaiknow-google-rank-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "domain"
                ],
                "properties": {
                    "domain": {
                        "title": "Your domain",
                        "minLength": 1,
                        "maxLength": 250,
                        "type": "string",
                        "description": "The domain whose Google rankings you want to check, e.g. 'yourdomain.com'. Full URLs work too — protocol / www. / path are stripped automatically. Subdomains count as ranking (blog.yourdomain.com counts for yourdomain.com)."
                    },
                    "keywords": {
                        "title": "Keywords",
                        "maxItems": 2000,
                        "type": "array",
                        "description": "Up to 2000 keywords (paid Apify plans) to check positions for. Each keyword is normalized (lowercased, whitespace collapsed) and deduplicated before any paid call. FREE PLAN: 25-keyword preview per run, desktop only; the actor exits early with an upgrade prompt above the limit. Leave empty and enable 'Seed from domain' to auto-populate the list (paid plans).",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 250
                        }
                    },
                    "location": {
                        "title": "Country / location",
                        "maxLength": 100,
                        "type": "string",
                        "description": "Full location name for the Google market the positions are checked in, e.g. 'United States', 'United Kingdom', 'Germany', 'Poland'. One market per run — run again for another market. Default 'United States'.",
                        "default": "United States"
                    },
                    "language": {
                        "title": "Language",
                        "maxLength": 100,
                        "type": "string",
                        "description": "Full language name for the market, e.g. 'English', 'German', 'Polish'. Default 'English'.",
                        "default": "English"
                    },
                    "device": {
                        "title": "Device",
                        "enum": [
                            "desktop",
                            "mobile",
                            "both"
                        ],
                        "type": "string",
                        "description": "Which Google results to check: 'desktop', 'mobile', or 'both'. 'both' runs two checks per keyword (two SERPs = two rank-check fees — honestly billed, it is twice the data). FREE PLAN: desktop only. Default 'desktop'.",
                        "default": "desktop"
                    },
                    "depth": {
                        "title": "SERP depth (top-20 / top-50 / top-100)",
                        "minimum": 20,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How deep to check each Google SERP: 20 (default), 50, or 100 results. Deeper SERPs cost proportionally more upstream, so they bill more rank-check events per keyword: top-20 = 1×, top-50 = 2×, top-100 = 4× (the per-event price never changes). Other values round UP to the next allowed depth (e.g. 30 → 50). FREE PLAN: fixed to top-20. If your domain is not found, the row says so relative to the depth checked (serp_depth field).",
                        "default": 20
                    },
                    "includeVolume": {
                        "title": "Volume enrichment (included in price)",
                        "type": "boolean",
                        "description": "Add estimated monthly search volume, CPC and competition to each keyword row so lost rankings can be prioritized by value. Included in the rank-check price — no extra fee. Paid Apify plans only (forced off on the free preview). Default true.",
                        "default": true
                    },
                    "seedFromDomain": {
                        "title": "Add-on: seed keywords from domain",
                        "type": "boolean",
                        "description": "Auto-populate the keyword list with the keywords your domain ALREADY ranks for (highest-volume first) — 'track what you rank on' without typing a list. Extra per-seeded-keyword fee (see README pricing); charged only for seeded keywords that actually reach the dataset. Paid Apify plans only. Default false.",
                        "default": false
                    },
                    "seedLimit": {
                        "title": "Seed limit",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of keywords to seed from the domain (only with 'Seed from domain'). Default 100, max 500. Total keywords per run stay capped at 2000.",
                        "default": 100
                    },
                    "bypassRunCache": {
                        "title": "Bypass 24h run-cache",
                        "type": "boolean",
                        "description": "Skip the 24h KV Store run-cache and take a fresh live SERP snapshot. You will be charged the per-check fees again. Default false.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```